* exposed number of subsamples in auto-level determination
* Removing print statement at @NilsNemitz's request
* make levelSamples count pixels, not pixels * channels
* minimum number of samples can be 2 if we look at pixels anyway
* adjusted minimum levelSamples to 4: Otherwise a 2x2 image downsamples to a single pixel
* extended docstring for level to make the user aware of auto-level subsampling
* subsample towards square array for auto-leveling
* eliminated duplicated code between level downsampling and samples and QuickMinMax method
Co-authored-by: Ogi Moore <ognyan.moore@gmail.com>
* add axis convenient methods and matrix display example
* wrestled wayward space back into docstring
* color map names are case sensitive on Linux
* docstring fix for PlotItem
* protect AxisItem.linkToView from being obscured by DateAxisItem override
* replaced setOrigin method by promoted setPos and setScale
* made tri-state axes switching explicit
* reverted setRect behavior, documentation pass for ImageItem
* minor text adjustment
* implmented some suggested revisions
* fix input parsing for setRect and add tests so that I don't break it again
* don't try to re-add transform after clearing it
* changed example and doc image generators to pg.exec()
* removed commented-out code
* cleaned up transform eqaulity assertion
* restored devoured comment
* restored devoured comment
With some experimentation, it was determined that when the QPainterPath
is drawn with a QPen that has a thickness greater than 1, the end result
is quite broken. Due to us trying to exploit non-advertised behavior
we are removing this optimization step.
* Update GLViewWidget.py
Fix the wrong conversion of QVector3D to numpy array.
* new way to fix the conversion error
* Recover prev. version of pixelSize
Co-authored-by: Jaeyoon Jeong <diem389@gmail.com>
Several bugs have snuck through due to being wrapped with printExc,
which would prevent the exception from raising, but printing the trace
to the console. In pytest, this output is not captured at all, and is
invisible unless the -s parameter is added.
This PR changes the print statement to a runtime warning, which pytest
will capture.
To reduce complexity, and make it easier to add more images and tests,
the images in the `test-data` repository should be merged with the main
repository. Furthermore, we can remove a lot of the subprocess work in
the image_testing.py file, as we no longer need to have it interact with
git.
The images are not the same. Images were regenerated with Qt6, and now
have proper big and little endian handling thanks to @pijyoi
Second commit is a slightly modified variant of
2e135ab282d6007b34a3854921be54d0e9efb241 authored by @pijyoi
it is to convert qimages to RGBA8888 for testing. Image
files were regenerated images for the big/little handling
Fixed issue with bogus test from test_NonUniformImage and generated a
new image
Since the QPainterPath.addPolygon(QPolygonF) does not filter out the NaN
values, we can insert NaN values to create discontinuities in the Lines,
and thus supporting connect='pairs' functionality
As discussed earlier, the process of QDataStream >> QPainterPath is
quite slow, so this commit makes an improvement on QPainterPath creation
for the case of connect='pairs' by using a naive method of moving the
path and drawing a line on the path. This was the fastest method
identified during testing.
The check for NaN values in arrayToQPath is expensive, this change
attempts to do the check one time, and if no NaN values are present,
an optional flag is passed along telling arrayToQPath that the check
can be skipped
Since QDataStream >> QPainterPath is an expensive operation, we can
construct our QPainterPath from an open polygon instead but only if the
connect='all' mode is present. Future optimizations work can likely
be had with constructing a polygon from each connected segment
* refactor out _ndarray_to_qimage()
* combine levels back with lut
* make use of Grayscale8, RGB888 and Indexed8 QImage formats
Grayscale8 and RGB888 images are those that are ready for display
without further processing.
* add Grayscale16
* apply the efflut early for uint16 mono/rgb, uint8 rgb
* ndarray indexing is faster than np.take
* handle uint16 rgb(a) with no levels same as levels=[0, 65535]
* add support for Format_RGBA64
* fix: support colormaps of shape (h, 1)
* check ImageItem uint8 and uint16 QImage formats
* uint16 mono with rgb lut -> RGBX8888
* got width and height swapped in array dimensions
* set ImageItem as row-major
* no need to form a 1d 32-bit lut for array indexing
you can index (y, x) into a lookup table of shape (nentry, 3) or
(nentry, 4) and get an output of shape (y, x, 3) or (y, x, 4)
* Revert "no need to form a 1d 32-bit lut for array indexing"
This reverts commit 45cf3100de.
* distinguish between levels_lut and colors_lut
this allows uint16 images with user lut to be rendered as
Format_Indexed8
* uint8 (1-chan) images should always combine to efflut
this efflut will then be used for Indexed8 format color table.
previously, we would be taking a performance hit with doing a numpy
lookup with levels_lut.
* adapt benchmarks/makeARGB.py to renderImageItem.py
* restructure uint8 and uint16 codepaths
* normalize 1-chan images to ndim==2 earlier up
* refactor long code into functions
* bug: qimage may not be assigned
* fix: assign to self.qimage only if not None
* for uint16, do rescale rather than do levels_lut lookup
* cases 2,3 are already handled
i.e. no more using lut to do rescale of uint16 image data.
* rescale rgb images by computation, not by memory lookup
* setImage() does not take an output argument
* try to be cupy compatible
use "xp" instead of numpy module
* add numba to benchmarking
* fix: lut_big is dtype uint8 with more than 256 entries
* bug: applying colors_lut needs C-order
* support float with no nans
* fix: variable could be uninitialized
* add float32 format tests
* avoid explicitly forcing to C-contiguous
* cache effective lut only if combination took place
every one of the four branches now does its own return.
this makes it easier to follow.
* fix cupy benchmark : typo in renderQImage
* remove for loop of 1 iteration
* use float32 for floating point benchmark
* superceded by renderImageItem.py
* lint
* benchmark without lut conversion
* put the lut onto the substrate
* fix editor complaints
* handle lack of cupy
* leading underscores imply privacy
Co-authored-by: KIU Shueng Chuan <nixchuan@gmail.com>
this also fixes the assumption that we are on little-endian.
In [18]: qimg = QtGui.QImage(1, 1, QtGui.QImage.Format.Format_RGB32)
In [19]: qimg.fill(QtCore.Qt.GlobalColor.transparent)
In [20]: np.frombuffer(qimg.bits(), dtype=np.uint8)
Out[20]: array([ 0, 0, 0, 255], dtype=uint8)
* added convenience functions to better handle plotting with gradients
* docstring correction, example name correction
* retrying to get documentation format right
* another attempt at cleaning up docs
* Don't hardcode timer type (and docs fixing attempt)
* more docstring re-formatting
* linebreaks in docstrings
* more documentation adjustments
* documentation pass
* some corrections to documentation
* more adjustments to documentation
* again?
* removed some whitespace and redundant blank lines, changed some checks '== None' to 'is None'
* fixed mis-spelling QColor as Qcolor
* Improve HistogramLUTItem docs, a few cosmetic changes
* Initial implementation of horizontally-oriented HistogramLUTItem
- Also adds support in HistogramLUTWidget
- Fixes AxisItem orientation bug for vertical orientation
- Make use of GradientEditorItem orientation (fixes another bug for
vertical orientation)
- Use horizontal orientation in an example for demonstration
* Remove unused HistogramLUTItem option
* A few more minor fixups
* Copy paste bug
* Use f-strings
* Update from review and a couple more minor updates
* Woops
* Add doc for orientation arg
* Add top/bottom orientation to doc. Expand on levelMode doc a bit
* do not cache the cupy so the config option can be set later
* getCupy will always return None if the option is not set
* test of failing behavior
* divorce skip from option; restore option after test
* implement rescale using numba
* workaround to pass test_makeARGB.py
* key on (input, output) manually
* remove minimum version check
* signature needs to be a list of signatures
numba considers it a mistake for single-item non-list but works around
it internally
* add numba test to test_makeARGB.py
* add numba as dependency in CI
* handle properly the case where useNumba was already True
* restore useCupy setting after test
* filter numba nan warning
* don't make changes to test_cupy_makeARGB_...
This change makes use of QPointF methods which perform faster than the python
equivalent methods. Furthermore, some tests are added.
* Set __slots__ to empty tuple for pg.Point
* Make Point.angle() behave as Vector.angle()
Static code checker identified multiple places where a file is opened
but is not necessarily closed. This commit addressed that with the
exception of RemoteGraphicsView.py
In a few places in the library, we are doing the conversion from radians
to degrees just so we can call QTransform.rotate(), but there is a
QTransform.rotateRadians() method which would be more suitable, thus
making it so we do not have to handle the conversions ourselves
python any and all are able to break early the moment they come across a
member of the iterable that meets the condition; but having a list
comprehension nested within breaks that ability to exit early, as the
list comprehension has to finish being constructed first before it can
be evaluated
Various places in the library attempt to check if scalars are finite
via numpy methods, which are intended to be used on numpy arrays. Using
the math module equivalent functions on scalars is significantly faster.
In a few places, I also use numpy methods explicitly (np.all vs. all)
Many places in the library were doing radian to degree conversion
via the manual calculation. Doing timeit benchmarks on my system, I
am able to get a 4x speedup by using math.degrees or math.radians
instead
Significant performance issues have been identified with np.clip
and thus clip_array was created to speed up the operation. In addition
clip_scalar was created to clip a scalar value between two other values
this commit replaces many uses of np.clip from operating on scalars to
using clip_scalar instead
Using numpy methods that are intended for vectorized operations is
substantially slower than using the math module, so when feasible the
math module methods should be used.
* NEW features for HistgramLUTItem
* gradientPosition=('left', 'right')
* only paint if item is visible (is faster)
* link hisogram to other histograms
* fixes to be able to merge
* drop linkHistogram (rgba needs to be better integrated)
* make sure defaults to same as current behavior
* draw connecting lines correctly on each side
* add example use
* update to working
* cupy tests, too
* doubling up and down
* add more realism to the benchmarks
* name to reflect scale
* use different numbers to mean different numbers
(that sure does sound tautological)
* more sensible: order, error
* thorough check of lots of makeARGB arg combos
* docstring for tool usage
* no print needed
* better error messages
* test makeARGB using cupy, too
* skip without cupy available
* switch from conda to venv
* skip cupy runs when not available
* use endian-proof makeARGB shim in tests
* generate the asv conf to suit the system
* document running asv
* comments for future matrix goals
* put all makeARGB tests together; name for clarity
* subprocess.check_output is standard for all supported pythons
* better handle lack of git version
* use makeARGB shim
* small fixes and improvements
* Fix the `clickable` property of `PlotDataItem`.
Currently if you attempt to set the `clickable` property of a PlotDataItem,
this property is silently ignored. The expected behavior is to set the
`clickable` property of the underlying PlotCurveItem.
* Use setCurvesClickable and curvesClickable instead
* curve is singular
PyQt6 can serialize / deserialize enums and flags w/o us manually
casting them to int.
In PyQt6 6.0, it was okay to pass the already deserialized flag
back to the class constructor.
In PyQt6 6.1, the flags MouseButtons and KeyboardModifiers have
been renamed to MouseButton and KeyboardModifier respectively.
skipping the reconstruction allows it to work on both PyQt6 6.0 and 6.1.
note that this was already done in deserialize_mouse_event()
the "offset" argument passed into rescaleData() is typically an element
of an ndarray, i.e. it comes from the lower bound value of the "levels"
ndarray. as such, arithmetic operations on it can overflow.
this triggers a runtime warning in the test suite.
the workaround is to convert it to a Python (integer) scalar.
* ROI.py, getArrayRegion: Fix return mapped coordinates
The *getArrayRegion* method is defined as returning a tuple of the points
in the selected region and the mapped coordinates if the
*returnMappedCoords* keyword argument is set to True in the parent class
*ROI*.
In the *EllipseROI* class, *getArrayRegion* was overriden, however it
ignores the *returnMappedCoords* keyword argument, leading to unintended
bugs because of the change in interface between the parent class and
the subclass.
This patch fixes the above bug.
If *returnMappedCoords* is set to False, then only *arr* containing the
array region is returned. If *returnMappedCoords* is set to True, a
tuple of the array region and the mapped coordinates is returned.
NB: At the time of this commit, the same bug is present in several classes
extending *ROI*. This commit only fixes the issue for the *EllipseROI* class.
* ROI.py, PolyLineROI.getArrayRegion: Fix return mapped coordinats
The *getArrayRegion* method is defined as returning a tuple of the
points in the selected region and the mapped coordinates if the
*returnMappedCoords* keyword argument is set to True in the parent class
*ROI*.
In the *PolyLineROI* class, *getArrayRegion* was overriden, however it
ignores the *returnMappedCoords* keyword argument, leading to unintended
bugs because of the change in interface between the parent class and the
subclass.
This patch fixes the above bug. If *returnMappedCoords* is set to
False, then only *arr* containing the array region is returned. If
*returnMappedCoords* is set to True, a tuple of the array region and the
mapped coordinates is returned.
* remove merge conflict cruft
* lint
Co-authored-by: Malik Olivier Boussejra <malik@boussejra.com>
* implement rescaleData_blocked
clip limits should be int if data is int
* add test for rescaleData_blocked
* dispatch to different versions depending on numpy or cupy
* make rescaleData() the only entry-point
* Initial implementation of ColorBarItem
* initial commit
* fixed missing indent
* docstring extension and corrections
* Converted example to match others / run as part of tests
* load local color maps instead of importing from colorcet
* clean up window creation code
* horizontal color bar and clean-up
* switched to mkQApp initialization
* cleaned up some comments
* allowed style updates to once again update the style of curve and scatter plot, added tests
* tests interleave assign and assert to guard against delayed assignment
* > > > now 100% more camels < < <
* Remove warning about existing QApplication
* Remove reference to weave which we do not use
* Do away with opengl warning
* Remove weaveDebug config option
* fix clip_array()
return error for invalid inputs.
use minmax for win32, umath.clip for other platforms
the previous code was penalizing Linux
* force output to be an array
Qt5 docs specify differences between QGLWidget and QOpenGLWidget:
"...when invoking paintGL().
QOpenGLWidget sets up the viewport via glViewport().
It does not perform any clearing."
* feature TriangleROI
Added equilateral TriangleROI.
getArrayRegion is not working yet
* show off (and implicitly test) our new TriangleROI
* the PolyLineROI.getArrayRegion can be used by TriangleROI
refactor the actual logic to live on ROI
* refactors for readability
* variable names
* lint
* docstring type and purpose
Co-authored-by: Fekete Imre <feketeimre87@gmail.com>
* Fix ScatterPlotItem performance regression
* Add hover benchmark to ScatterPlotSpeedTest.py
* Removed a performance regression from GraphicsView
* Removed some tests failing due to the last commit
the previous formulation creates an ndarray and then creates an QImage
over it w/o copying. this relies on the QImage thus created being
non-const.
if the QImage was (unintentionally) created as const, the subsequent
QPainter render on the const QImage would trigger a COW. i.e. the
original underlying ndarray wouldn't be updated.
this is only an issue for PyQt bindings where const QImages can be
created.
Nils Nemitz
Ogi Moore
bsobhani
shikishima-TasakiLab
KIU Shueng Chuan
njessurun
3DAlgoLab
Luke Campagnola
Martin Chase
Wyatt Ubellacker
Kenneth Lyons
Mark Schloeman
shahmustafa54
Fernando Bordignon
Christopher Mullins
Kyle Sunden
Dennis Göries
Nathan Jessurun
Daniel Lidstrom
Chris Mullins
Rafael Irgolic