QuickGraphLib 0.1.0a0__tar.gz

QuickGraphLib-0.1.0a0/LICENCE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Matthew Joyce and other QuickGraphLib contributors
+
+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.

QuickGraphLib-0.1.0a0/MANIFEST.in

@@ -0,0 +1 @@
+recursive-include QuickGraphLib *.qml *.js qmldir

QuickGraphLib-0.1.0a0/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.1
+Name: QuickGraphLib
+Version: 0.1.0a0
+Summary: A scientific graphing library for QtQuick
+Author-email: Matthew Joyce <matthew.joyce@refeyn.com>
+License: MIT License
+        
+        Copyright (c) 2024 Matthew Joyce and other QuickGraphLib contributors
+        
+        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.
+Project-URL: Homepage, https://github.com/refeyn/QuickGraphLib
+Project-URL: Issues, https://github.com/refeyn/QuickGraphLib/issues
+Project-URL: Source, https://github.com/refeyn/QuickGraphLib
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: X11 Applications :: Qt
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Topic :: Multimedia :: Graphics :: Presentation
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Classifier: Topic :: Software Development :: User Interfaces
+Classifier: Typing :: Typed
+Description-Content-Type: text/markdown
+License-File: LICENCE
+Requires-Dist: PySide6
+Requires-Dist: contourpy
+Provides-Extra: analyse
+Requires-Dist: black; extra == "analyse"
+Requires-Dist: pylint; extra == "analyse"
+Requires-Dist: mypy; extra == "analyse"
+Requires-Dist: pre-commit; extra == "analyse"
+Requires-Dist: lxml; extra == "analyse"
+Requires-Dist: pytest; extra == "analyse"
+Requires-Dist: pytest-cov; extra == "analyse"
+
+# QuickGraphLib
+
+A scientific graphing library for [QtQuick](https://doc.qt.io/qt-6/qtquick-index.html) using Qt6.
+
+Key advantages:
+
+ - Written in pure QML (with some optional Python helpers), so it can be used in both C++ and Python projects
+ - QtQuick's hardware-based rendering makes this library render very fast
+ - Support for line graphs, histograms, contour plots and more
+ - Interactivity supported natively though declarative bindings and QtQuick
+ - Support for PNG and SVG export
+
+## Examples
+
+The example gallery can be run using (provided the Python environment has [PySide6](https://pypi.org/project/PySide6/) and [contourpy](https://pypi.org/project/contourpy/) installed):
+
+```bash
+python examples\gallery.py
+```
+
+<p align="center"><img src="./examples/ExampleGallery.png" width="80%"></p>

QuickGraphLib-0.1.0a0/QuickGraphLib/AntialiasingContainer.qml

@@ -0,0 +1,18 @@
+// SPDX-FileCopyrightText: Copyright (c) 2024 Matthew Joyce and other QuickGraphLib contributors
+// SPDX-License-Identifier: MIT
+
+import QtQuick
+
+/*!
+    \qmltype AntialiasingContainer
+    \inqmlmodule QuickGraphLib
+    \inherits QtQuick::Item
+    \brief Enables antialiasing for it's contents.
+*/
+
+Item {
+    implicitHeight: 100
+    implicitWidth: 100
+    layer.enabled: true // Improves rendering of fractional DPIs
+    layer.samples: 2
+}

QuickGraphLib-0.1.0a0/QuickGraphLib/Axis.qml

@@ -0,0 +1,227 @@
+// SPDX-FileCopyrightText: Copyright (c) 2024 Matthew Joyce and other QuickGraphLib contributors
+// SPDX-License-Identifier: MIT
+
+pragma ComponentBehavior: Bound
+import QtQuick
+import QtQuick.Shapes as QQS
+
+/*!
+    \qmltype Axis
+    \inqmlmodule QuickGraphLib
+    \inherits QtQuick::Item
+    \brief Displays an Axis.
+*/
+
+Item {
+    id: root
+
+    enum Direction {
+        Left,
+        Right,
+        Top,
+        Bottom
+    }
+
+    property list<point> _path: _calculateTickPath(ticks, direction, width, height, dataTransform)
+    property list<int> _tickPositions
+    /*!
+        TODO
+        \sa {GraphArea::dataTransform}
+    */
+    required property matrix4x4 dataTransform
+    /*! TODO */
+    property int decimalPoints: 2
+    /*! TODO
+
+
+        \value Axis.Direction.Left Axis to the left of the GraphArea
+        \value Axis.Direction.Right Axis to the right of the GraphArea
+        \value Axis.Direction.Top Axis above of the GraphArea
+        \value Axis.Direction.Bottom Axis below of the GraphArea
+     */
+    required property int direction
+    /*! TODO */
+    property alias label: labelText.text
+    /*! TODO */
+    property bool showTickLabels: true
+    /*! TODO */
+    property double spacing: 4
+    /*! TODO */
+    property double tickLength: 10
+    /*! TODO */
+    required property list<double> ticks
+
+    function _calculateTickPath(ticks, direction: int, width: double, height: double, dataTransform) {
+        const longAxis = direction == Axis.Direction.Top || direction == Axis.Direction.Bottom ? width : height;
+        let transformedTicks = ticks.map(t => dataTransform.map(Qt.point(t, t))[direction == Axis.Direction.Top || direction == Axis.Direction.Bottom ? "x" : "y"]);
+
+        // Calculate everything as if we were a bottom axis
+        let points = [Qt.point(0, 0)], tickPositions = [];
+        transformedTicks.forEach(t => {
+            if (t >= -0.5 && t <= longAxis + 0.5) {
+                points.push(Qt.point(t, 0));
+                points.push(Qt.point(t, root.tickLength));
+                points.push(Qt.point(t, 0));
+                tickPositions.push(points.length - 2);
+            } else {
+                tickPositions.push(-1);
+            }
+        });
+        points.push(Qt.point(longAxis, 0));
+        _tickPositions = tickPositions;
+
+        // Transform into the correct positions
+        switch (root.direction) {
+        case Axis.Direction.Left:
+            return points.map(p => Qt.point(width - p.y, p.x));
+        case Axis.Direction.Right:
+            return points.map(p => Qt.point(p.y, p.x));
+        case Axis.Direction.Top:
+            return points.map(p => Qt.point(p.x, height - p.y));
+        case Axis.Direction.Bottom:
+            return points;
+        }
+    }
+
+    implicitHeight: {
+        switch (root.direction) {
+        case Axis.Direction.Left:
+        case Axis.Direction.Right:
+            return 100;
+        case Axis.Direction.Top:
+        case Axis.Direction.Bottom:
+            let height = 0;
+            if (ticks.length > 0) {
+                height += root.tickLength + Math.max(0, ...[...Array(tickLabels.count).keys()].map(i => tickLabels.itemAt(i)?.height));
+            }
+            if (label != "") {
+                height += labelText.height + root.spacing;
+            }
+            return height;
+        }
+    }
+    implicitWidth: {
+        switch (root.direction) {
+        case Axis.Direction.Left:
+        case Axis.Direction.Right:
+            let width = 0;
+            if (ticks.length > 0) {
+                width += root.tickLength + Math.max(0, ...[...Array(tickLabels.count).keys()].map(i => tickLabels.itemAt(i)?.width));
+            }
+            if (label != "") {
+                width += labelText.height + root.spacing;
+            }
+            return width;
+        case Axis.Direction.Top:
+        case Axis.Direction.Bottom:
+            return 100;
+        }
+    }
+    z: 1
+
+    QQS.Shape {
+        id: shape
+
+        anchors.fill: parent
+
+        QQS.ShapePath {
+            id: myPath
+
+            startX: root._path[0].x
+            startY: root._path[0].y
+            strokeColor: "black"
+            strokeWidth: 1
+
+            PathPolyline {
+                path: root._path
+            }
+        }
+    }
+    Repeater {
+        id: tickLabels
+
+        model: root.showTickLabels ? root.ticks : []
+
+        Text {
+            required property int index
+            required property double modelData
+
+            leftPadding: 2
+            rightPadding: 2
+            text: Number(modelData).toFixed(root.decimalPoints)
+            visible: root._tickPositions[index] >= 0
+            x: {
+                let baseX = root._path[root._tickPositions[index]]?.x ?? 0;
+                switch (root.direction) {
+                case Axis.Direction.Left:
+                    return baseX - width;
+                case Axis.Direction.Right:
+                    return baseX;
+                case Axis.Direction.Top:
+                    return baseX - width / 2;
+                case Axis.Direction.Bottom:
+                    return baseX - width / 2;
+                }
+            }
+            y: {
+                let baseY = root._path[root._tickPositions[index]]?.y ?? 0;
+                switch (root.direction) {
+                case Axis.Direction.Left:
+                    return baseY - height / 2;
+                case Axis.Direction.Right:
+                    return baseY - height / 2;
+                case Axis.Direction.Top:
+                    return baseY - height;
+                case Axis.Direction.Bottom:
+                    return baseY;
+                }
+            }
+        }
+    }
+    Text {
+        id: labelText
+
+        x: {
+            switch (root.direction) {
+            case Axis.Direction.Left:
+                return height / 2;
+            case Axis.Direction.Right:
+                return root.width - height / 2;
+            case Axis.Direction.Top:
+            case Axis.Direction.Bottom:
+                return root.width / 2;
+            }
+        }
+        y: {
+            switch (root.direction) {
+            case Axis.Direction.Left:
+            case Axis.Direction.Right:
+                return root.height / 2;
+            case Axis.Direction.Top:
+                return height / 2;
+            case Axis.Direction.Bottom:
+                return root.height - height / 2;
+            }
+        }
+
+        transform: [
+            Translate {
+                x: -labelText.width / 2
+                y: -labelText.height / 2
+            },
+            Rotation {
+                angle: {
+                    switch (root.direction) {
+                    case Axis.Direction.Left:
+                        return -90;
+                    case Axis.Direction.Right:
+                        return 90;
+                    case Axis.Direction.Top:
+                    case Axis.Direction.Bottom:
+                        return 0;
+                    }
+                }
+            }
+        ]
+    }
+}

QuickGraphLib-0.1.0a0/QuickGraphLib/GraphArea.qml

@@ -0,0 +1,54 @@
+// SPDX-FileCopyrightText: Copyright (c) 2024 Matthew Joyce and other QuickGraphLib contributors
+// SPDX-License-Identifier: MIT
+
+import QtQuick
+import QtQuick.Shapes as QQS
+
+/*!
+    \qmltype Histogram
+    \inqmlmodule QuickGraphLib
+    \inherits QtQuick::Shapes::Shape
+    \brief An area that graphs can be added to.
+*/
+
+QQS.Shape {
+    id: root
+
+    /*!
+        Transform from data coordinates to pixel coordinates inside the GraphArea with the viewTransform applied
+    */
+    readonly property matrix4x4 dataTransform: viewTransform.times(rawDataTransform)
+    /*!
+        The view rect the view is actually showing based on viewTransform
+    */
+    readonly property rect effectiveViewRect: {
+        let mat = rawDataTransform.inverted().times(viewTransform.inverted().times(rawDataTransform));
+        return mat.mapRect(viewRect);
+    }
+    /*!
+        Transform from data coordinates to pixel coordinates inside the GraphArea
+    */
+    readonly property matrix4x4 rawDataTransform: {
+        let mat = Qt.matrix4x4();
+        // Flip coordinate system so that Y points upwards
+        mat.translate(Qt.vector3d(0, root.height, 0));
+        mat.scale(root.width / viewRect.width, -root.height / viewRect.height, 1);
+        mat.translate(Qt.vector3d(-viewRect.x, -viewRect.y, 0));
+        return mat;
+    }
+    /*! TODO */
+    required property rect viewRect
+    /*! TODO */
+    property matrix4x4 viewTransform
+
+    function baseTransformFromRect(r: rect): matrix4x4 {
+        let mat = Qt.matrix4x4();
+        mat.scale(viewRect.width / r.width, viewRect.height / r.height, 1);
+        mat.translate(Qt.vector3d((viewRect.x - r.x) / viewRect.width, (r.y + r.height - viewRect.y - viewRect.height) / viewRect.height, 0));
+        return mat;
+    }
+
+    clip: true
+    implicitHeight: 100
+    implicitWidth: 100
+}

QuickGraphLib-0.1.0a0/QuickGraphLib/GraphItems/AxHLine.qml

@@ -0,0 +1,25 @@
+// SPDX-FileCopyrightText: Copyright (c) 2024 Matthew Joyce and other QuickGraphLib contributors
+// SPDX-License-Identifier: MIT
+
+import QtQuick
+
+/*!
+    \qmltype AxHLine
+    \inqmlmodule QuickGraphLib.GraphItems
+    \inherits QtQuick::Rectangle
+    \brief Displays a horizontal line.
+*/
+
+Rectangle {
+    id: root
+
+    /*! TODO */
+    required property matrix4x4 dataTransform
+    /*! TODO */
+    required property double position
+
+    height: 2
+    width: parent.width + border.width * 4
+    x: -border.width * 2
+    y: root.dataTransform.map(Qt.point(0, position)).y - height / 2
+}

QuickGraphLib-0.1.0a0/QuickGraphLib/GraphItems/AxHSpan.qml

@@ -0,0 +1,28 @@
+// SPDX-FileCopyrightText: Copyright (c) 2024 Matthew Joyce and other QuickGraphLib contributors
+// SPDX-License-Identifier: MIT
+
+import QtQuick
+
+/*!
+    \qmltype AxHSpan
+    \inqmlmodule QuickGraphLib.GraphItems
+    \inherits QtQuick::Rectangle
+    \brief Displays a horizontal span.
+*/
+
+Rectangle {
+    id: root
+
+    /*! TODO */
+    required property matrix4x4 dataTransform
+    /*! TODO */
+    required property double yMax
+    /*! TODO */
+    required property double yMin
+
+    border.width: 0
+    height: root.dataTransform.map(Qt.point(0, yMin)).y - root.dataTransform.map(Qt.point(0, yMax)).y
+    width: parent.width + border.width * 4
+    x: -border.width * 2
+    y: root.dataTransform.map(Qt.point(0, yMax)).y
+}

QuickGraphLib-0.1.0a0/QuickGraphLib/GraphItems/AxVLine.qml

@@ -0,0 +1,25 @@
+// SPDX-FileCopyrightText: Copyright (c) 2024 Matthew Joyce and other QuickGraphLib contributors
+// SPDX-License-Identifier: MIT
+
+import QtQuick
+
+/*!
+    \qmltype AxVLine
+    \inqmlmodule QuickGraphLib.GraphItems
+    \inherits QtQuick::Rectangle
+    \brief Displays an vertical line.
+*/
+
+Rectangle {
+    id: root
+
+    /*! TODO */
+    required property matrix4x4 dataTransform
+    /*! TODO */
+    required property double position
+
+    height: parent.height + border.width * 4
+    width: 2
+    x: root.dataTransform.map(Qt.point(position, 0)).x - width / 2
+    y: -border.width * 2
+}

QuickGraphLib-0.1.0a0/QuickGraphLib/GraphItems/AxVSpan.qml

@@ -0,0 +1,28 @@
+// SPDX-FileCopyrightText: Copyright (c) 2024 Matthew Joyce and other QuickGraphLib contributors
+// SPDX-License-Identifier: MIT
+
+import QtQuick
+
+/*!
+    \qmltype AxVSpan
+    \inqmlmodule QuickGraphLib.GraphItems
+    \inherits QtQuick::Rectangle
+    \brief Displays an vertical span.
+*/
+
+Rectangle {
+    id: root
+
+    /*! TODO */
+    required property matrix4x4 dataTransform
+    /*! TODO */
+    required property double xMax
+    /*! TODO */
+    required property double xMin
+
+    border.width: 0
+    height: parent.height + border.width * 4
+    width: root.dataTransform.map(Qt.point(xMax, 0)).x - root.dataTransform.map(Qt.point(xMin, 0)).x
+    x: root.dataTransform.map(Qt.point(xMin, 0)).x
+    y: -border.width * 2
+}

QuickGraphLib-0.1.0a0/QuickGraphLib/GraphItems/BasicLegend.qml

@@ -0,0 +1,29 @@
+// SPDX-FileCopyrightText: Copyright (c) 2024 Matthew Joyce and other QuickGraphLib contributors
+// SPDX-License-Identifier: MIT
+
+import QtQuick
+
+/*!
+    \qmltype BasicLegend
+    \inqmlmodule QuickGraphLib.GraphItems
+    \inherits QtQuick::Rectangle
+    \brief Displays a simple legend.
+*/
+
+Rectangle {
+    /*! TODO */
+    default property alias contentChildren: legend.children
+    /*! TODO */
+    property alias verticalSpacing: legend.spacing
+
+    border.color: "black"
+    color: "#aaffffff"
+    height: legend.height + 10
+    width: legend.width + 10
+
+    Column {
+        id: legend
+
+        anchors.centerIn: parent
+    }
+}

QuickGraphLib-0.1.0a0/QuickGraphLib/GraphItems/BasicLegendItem.qml

@@ -0,0 +1,54 @@
+// SPDX-FileCopyrightText: Copyright (c) 2024 Matthew Joyce and other QuickGraphLib contributors
+// SPDX-License-Identifier: MIT
+
+import QtQuick
+
+/*!
+    \qmltype BasicLegendItem
+    \inqmlmodule QuickGraphLib.GraphItems
+    \inherits QtQuick::Row
+    \brief An single entry in a simple legend.
+*/
+
+Row {
+    id: root
+
+    /*! TODO */
+    property color fillColor: "transparent"
+    /*! TODO */
+    property Gradient fillGradient: null
+
+    /*! TODO */
+    property color strokeColor: "black"
+    /*! TODO */
+    property real strokeWidth: 1
+    /*! TODO */
+    property alias text: label.text
+
+    spacing: 2
+
+    Item {
+        id: clipper
+
+        anchors.verticalCenter: parent.verticalCenter
+        clip: true
+        height: root.height - 2
+        width: root.height - 2
+
+        Rectangle {
+            border.color: root.strokeColor
+            border.width: root.strokeWidth
+            color: root.fillColor
+            gradient: root.fillGradient
+            height: clipper.height / 2 + root.strokeWidth * 2
+            width: clipper.width + root.strokeWidth * 4
+            x: -root.strokeWidth * 2
+            y: clipper.height / 2
+        }
+    }
+    Text {
+        id: label
+
+        anchors.verticalCenter: parent.verticalCenter
+    }
+}

QuickGraphLib-0.1.0a0/QuickGraphLib/GraphItems/Contour.qml

@@ -0,0 +1,33 @@
+// SPDX-FileCopyrightText: Copyright (c) 2024 Matthew Joyce and other QuickGraphLib contributors
+// SPDX-License-Identifier: MIT
+
+import QtQuick
+import QtQuick.Shapes as QQS
+
+/*!
+    \qmltype Contours
+    \inqmlmodule QuickGraphLib.GraphItems
+    \inherits QtQuick::Shapes::ShapePath
+    \brief Draw a contour line or fill.
+*/
+
+QQS.ShapePath {
+    id: root
+
+    /*!
+        TODO
+    */
+    required property matrix4x4 dataTransform
+    /*!
+        TODO
+    */
+    required property var paths
+
+    capStyle: QQS.ShapePath.RoundCap
+    fillColor: "transparent"
+    joinStyle: QQS.ShapePath.RoundJoin
+
+    PathMultiline {
+        paths: root.paths.map(ps => ps.map(p => root.dataTransform.map(p)))
+    }
+}

QuickGraphLib-0.1.0a0/QuickGraphLib/GraphItems/GraphItemDragHandler.qml

@@ -0,0 +1,39 @@
+// SPDX-FileCopyrightText: Copyright (c) 2024 Matthew Joyce and other QuickGraphLib contributors
+// SPDX-License-Identifier: MIT
+
+import QtQuick
+
+/*!
+    \qmltype GraphItemDragHandler
+    \inqmlmodule QuickGraphLib.GraphItems
+    \inherits QtQuick::MouseArea
+    \brief Assists converting mouse drags into data positions.
+*/
+
+MouseArea {
+    id: root
+
+    property rect _startDragPos
+
+    /*! TODO */
+    required property matrix4x4 dataTransform
+    /*! TODO */
+    property bool dragging
+
+    signal moved(rect position)
+
+    hoverEnabled: true
+
+    onPositionChanged: event => {
+        if (dragging) {
+            moved(dataTransform.inverted().mapRect(Qt.rect(parent.x + event.x - _startDragPos.x, parent.y + event.y - _startDragPos.y, _startDragPos.width, _startDragPos.height)));
+        }
+    }
+    onPressed: event => {
+        _startDragPos = Qt.rect(mouseX, mouseY, width, height);
+        dragging = true;
+    }
+    onReleased: event => {
+        dragging = false;
+    }
+}