QuickGraphLib 0.1.0a0__py3-none-any.whl

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/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/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/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/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/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/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/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/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/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/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;
+    }
+}

QuickGraphLib/GraphItems/Grid.qml

@@ -0,0 +1,58 @@
+// SPDX-FileCopyrightText: Copyright (c) 2024 Matthew Joyce and other QuickGraphLib contributors
+// SPDX-License-Identifier: MIT
+
+import QtQuick
+import QtQuick.Shapes as QQS
+
+/*!
+    \qmltype Grid
+    \inqmlmodule QuickGraphLib.GraphItems
+    \inherits QtQuick::Shapes::ShapePath
+    \brief Displays a grid in the background of a graph.
+*/
+
+QQS.ShapePath {
+    id: root
+
+    /*! TODO */
+    required property matrix4x4 dataTransform
+    /*! TODO */
+    required property double parentHeight
+    /*! TODO */
+    required property double parentWidth
+    /*! TODO */
+    property list<double> xTicks: []
+    /*! TODO */
+    property list<double> yTicks: []
+
+    function _calculateXPath(xTicks, dataTransform, parentHeight) {
+        let points = [];
+        xTicks.forEach(t => {
+            let x = dataTransform.map(Qt.point(t, 0)).x;
+            points.push(Qt.point(x, -10));
+            points.push(Qt.point(x, parentHeight + 10));
+            points.push(Qt.point(x, -10));
+        });
+        return points;
+    }
+    function _calculateYPath(yTicks, dataTransform, parentWidth) {
+        let points = [];
+        yTicks.forEach(t => {
+            let y = dataTransform.map(Qt.point(0, t)).y;
+            points.push(Qt.point(-10, y));
+            points.push(Qt.point(parentWidth + 10, y));
+            points.push(Qt.point(-10, y));
+        });
+        return points;
+    }
+
+    capStyle: QQS.ShapePath.RoundCap
+    joinStyle: QQS.ShapePath.RoundJoin
+
+    PathPolyline {
+        path: root._calculateXPath(root.xTicks, root.dataTransform, root.parentHeight)
+    }
+    PathPolyline {
+        path: root._calculateYPath(root.yTicks, root.dataTransform, root.parentWidth)
+    }
+}

QuickGraphLib/GraphItems/Histogram.qml

@@ -0,0 +1,50 @@
+// 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.GraphItems
+    \inherits QtQuick::Shapes::ShapePath
+    \brief Displays a histogram.
+*/
+
+QQS.ShapePath {
+    id: root
+
+    /*! TODO */
+    required property var bins
+    /*! TODO */
+    required property matrix4x4 dataTransform
+    /*! TODO */
+    required property var heights
+    /*! TODO */
+    property bool vertical: false
+
+    function _calculatePoints(bins, heights) {
+        if (bins.length != heights.length + 1) {
+            print(bins.length, heights.length);
+            return [];
+        }
+        let points = [Qt.point(bins[0], 0)];
+        heights.forEach((h, i) => {
+            points.push(Qt.point(bins[i], h));
+            points.push(Qt.point(bins[i + 1], h));
+        });
+        points.push(Qt.point(bins[bins.length - 1], 0));
+        if (root.vertical) {
+            return points.map(p => Qt.point(p.y, p.x));
+        } else {
+            return points;
+        }
+    }
+
+    capStyle: QQS.ShapePath.RoundCap
+    joinStyle: QQS.ShapePath.RoundJoin
+
+    PathPolyline {
+        path: root._calculatePoints(root.bins, root.heights).map(p => root.dataTransform.map(p))
+    }
+}