import pyqtgraph as pg
from pyqtgraph import QtCore, QtGui, QtWidgets

class CandlestickItem(pg.GraphicsObject):
    def __init__(self, data):
        pg.GraphicsObject.__init__(self)
        self.data = data  ## data must have fields: time, open, close, min, max
        self.generatePicture()
    
    def generatePicture(self):
        ## pre-computing a QPicture object allows paint() to run much more quickly, 
        ## rather than re-drawing the shapes every time.
        dataBounds = QtCore.QRectF()
        self.picture = QtGui.QPicture()
        p = QtGui.QPainter(self.picture)
        pen = pg.mkPen('w', width=6)
        p.setPen(pen)
        brush_pos = pg.mkBrush('r')
        brush_neg = pg.mkBrush('g')
        w = (self.data[1][0] - self.data[0][0]) / 3.
        for (t, open, close, min, max) in self.data:
            p.drawLine(QtCore.QPointF(t, min), QtCore.QPointF(t, max))
            if open > close:
                p.setBrush(brush_pos)
            else:
                p.setBrush(brush_neg)
            p.drawRect(QtCore.QRectF(t-w, open, w*2, close-open))
            dataBounds |= QtCore.QRectF(t-w, min, w*2, max-min)
        p.end()
        self._dataBounds = dataBounds
        self._pixelPadding = pen.widthF()*0.7072

    def paint(self, p, *args):
        p.drawPicture(0, 0, self.picture)
    
    def boundingRect(self):
        if self.picture is None:
            self.generatePicture()
        return QtCore.QRectF(self.picture.boundingRect())

class ItemX(CandlestickItem):
    # provide boundingRect that takes into account pen width
    def boundingRect(self):
        if self.picture is None:
            self.generatePicture()

        px = py = 0.0
        pxPad = self._pixelPadding
        if pxPad > 0:
            # determine length of pixel in local x, y directions
            px, py = self.pixelVectors()
            try:
                px = 0 if px is None else px.length()
            except OverflowError:
                px = 0
            try:
                py = 0 if py is None else py.length()
            except OverflowError:
                py = 0

            # return bounds expanded by pixel size
            px *= pxPad
            py *= pxPad
        boundingRect = self._dataBounds.adjusted(-px, -py, px, py)
        return boundingRect

class ItemY(ItemX):
    # also provide dataBounds and pixelPadding
    def dataBounds(self, ax, frac=1.0, orthoRange=None):
        if self.picture is None:
            self.generatePicture()
        br = self._dataBounds
        if ax == 0:
            return [br.left(), br.right()]
        else:
            return [br.top(), br.bottom()]

    def pixelPadding(self):
        if self.picture is None:
            self.generatePicture()
        return self._pixelPadding

class ObjectBounds(QtWidgets.QGraphicsItem):
    def paint(self, painter, *args):
        pen = QtGui.QPen(QtCore.Qt.GlobalColor.red, 0, QtCore.Qt.PenStyle.DashLine)
        rect = self.boundingRect()
        painter.setPen(pen)
        painter.drawRect(rect)
        # print(rect)

    def boundingRect(self):
        return self.parentItem().boundingRect()

data = [  ## fields are (time, open, close, min, max).
    (1., 10, 13, 5, 15),
    (2., 13, 17, 9, 20),
    (3., 17, 14, 11, 23),
    (4., 14, 15, 5, 19),
    (5., 15, 9, 8, 22),
    (6., 9, 15, 8, 16),
]

pg.mkQApp()
glw = pg.GraphicsLayoutWidget()
glw.show()
items = [CandlestickItem(data), ItemX(data), ItemY(data)]
rects = []
for idx, item in enumerate(items):
    plt = glw.addPlot(row=idx, col=0)
    plt.addItem(item)
    rects.append(ObjectBounds(item))
pg.exec()

import numpy as np
import pyqtgraph as pg
from pyqtgraph.Qt import QtCore, QtGui, QtWidgets

class ObjectBounds(QtWidgets.QGraphicsItem):
    def paint(self, painter, *args):
        pen = QtGui.QPen(QtCore.Qt.GlobalColor.red, 0, QtCore.Qt.PenStyle.DashLine)
        rect = self.boundingRect()
        painter.setPen(pen)
        painter.drawRect(rect)
        print(rect)

    def boundingRect(self):
        return self.parentItem().boundingRect()

pg.mkQApp()
pw = pg.PlotWidget()
pw.show()

x = np.linspace(0, 1, 100)
y = np.sin(2*np.pi*1.0*x)

pen = pg.mkPen('w', width=1)
bgi = pg.BarGraphItem(x=x, width=x[1]-x[0], height=y, pen=pen, brush=(0,0,255,150))
pw.addItem(bgi)
rect = ObjectBounds(bgi)

pg.exec()

"""
Returns the range occupied by the data (along a specific axis) in this item.
This method is called by :class:`ViewBox` when auto-scaling.
=============== ====================================================================
**Arguments:**
ax              (0 or 1) the axis for which to return this item's data range
frac            (float 0.0-1.0) Specifies what fraction of the total data
                range to return. By default, the entire range is returned.
                This allows the :class:`ViewBox` to ignore large spikes in the data
                when auto-scaling.
orthoRange      ([min,max] or None) Specifies that only the data within the
                given range (orthogonal to *ax*) should me measured when
                returning the data range. (For example, a ViewBox might ask
                what is the y-range of all data with x-values between min
                and max)
=============== ====================================================================
"""