make drawing trend lines simpler

[dattran2346]

Is there anyway that I can get the matplotlib axes/figure object and add my custom plotting on top.

I currently want to draw trendlines like this

ac = ([dateA, dateC], [priceA, priceC])
l = mlines.Line2D(*ac)
ax.add_line(l)

The result look like

[DanielGoldfarb]

You should be able to do this using the addplot= keyword to mpf.plot().
Please click here for documentation/examples.

The tend line data will need to be in a list, or pandas series or dataframe, that has the same length and datetime index as your original OHLC data. If there are dates over which you do not want the lines to extend (as in the picture you have provided) you can simply use NaN values at the dates over which you do not want to see the trend lines.

Let me know if that works for you.

[DanielGoldfarb]

a couple of thoughts on this:

• For this to work as noted in my previous comment above, you will have to generate a time series of data (rather that specify only two points as you did in your example).

  • However I see that is inconvenient, so I am thinking perhaps just for the simple case of trend lines, we could provide a kwarg trend= that accepts two dates and two prices as in your example. It could also accept a list of date/price pairs to be able to plot multiple trend lines.
  • This is not a priority at present, since there is the addplot() alternative, however if you would like to contribute such an enhancement I would consider reviewing and merging the code.

• there is a possibility, as was mentioned in this issue, that there will be an enhancement to allow mpf.plot() to return the Figure and Axes that it creates. In the meantime, you can do what is described above.

[DanielGoldfarb]

I did some experimenting with returning Figure and Axes. It didn't really work to allow me to add to the plot after calling mpf.plot(). And, it seemed to me, the issues that arose became only more challenging when I tried to make it work.

Anyone who wants to should feel free to experiment with returning Figure and Axes and let me know if you can get it to work without fundamentally changing the design of mplfinance. Keep in mind that the old API is still available and the approach of the old API is to give you full control and responsibility for the Figure and Axes. So if you really want access to Figure and Axes you can also just use the old API, since it is fundamentally designed for that.

Now, regarding trend lines, as I noted in a comment above, it is definitely possibly to plot them using the make_addplot() functionality. However the caller must generate the data for the trend line. This, it seems to me, is at least not particularly convenient. So I am going to leave this issue open as an enhancement to make drawing trend lines simpler.

I am considering an implementing this as a kwarg to make_addplot()

• trend= ... a tuple or list of two dates or four dates. If two dates, then the two dates define the trend line, going from close to close on the two sepcified dates. If four dates are provided then the second pair of dates extend the trend line somewhat beyond the two dates that define slope of the trend line.

[dattran2346]

As you noted above, I currently use the old candlestick_ohlc api to and plot the channel on the return figure/axes object.

Regarding the new trend line api as you suggested, I am thinking that it is more flexible to pass the list of points that users want to draw lines, and also more favorable to change trend=... to lines=..., since user may want to connect multiple interesting points on the chart, i.e, make_addplot(lines=[(dateA, priceA), (dateB, priceB), (dateC, priceC), ...]).

For example, I currently want to plot the double bottom pattern on the chart.

Ps: I would like to help you implement this enhancement,. let my know your opinion.

[DanielGoldfarb]

@dattran2346

Have you tried using make_addplot() as it exists now to draw these lines??

It simply requires that you have a list (or a Series with a DatetimeIndex) that is the same length as the original dataframe. That list (or Series) should contain the values from your list of date,price tuples, each in their correct location within the list (or Series), and contain NaN at all other points.

This is important, because the way that matplotlib handles not showing non-trading days is to use a range of integers for the x-axis (and then simply format them as dates). This is similar to candlestick2_ohlc(). In the new API you can see the code here where it converts dates to xdates which may or may not be actual dates.

This fact, the fact that internally the x-axis may be dates or may be integers, complicates the matter of you wanting to pass in a sparse list of date,price tuples.

The simpliest thing to do (as mentioned above) is to first convert your sparse list of date,price tuples into a Series (with the same length and same DatetimeIndex from the original ohlc dataframe). Inside this series, the dates corresponding to your date,price tuples would have the value (price) from the tuple, and all other dates would have a value of NaN. (I think that would work; if not we can always interpolate values).

If we were to take a more direct approach (similar to calling Line2D() in your original posting) then we would have to add code to mpf.plot() to do that. Function mpf.plot() would have to handle the special case of trend lines much differently from all of the other addplot configurations. This would complicate mpf.plot() making it more difficult to maintain over time.

Therefore, if you want to specify just a sparse list of date,price tuples, I suggest we write a function that converts such a sparse list to a Series as described above. Then the question becomes where to call that function.

One possibility is to call that function before calling make_addplot(), and to pass the output from that function into the data argument of make_addplot(). In this way, we would not need to make any changes to either make_addplot() nor plot(). We could call this function make_trendlines() or make_lines(). It would look something like this:

data = mpf.make_lines( [(dateA, priceA), (dateB, priceB), (dateC, priceC), ...] )
ap   = mpf.make_addplot(data,...)
mpf.plot( df, addplot=ap, ...)

Another possibility is to call the conversion function inside make_addplot(). If so, then, as you propose above, make_addplot() could have a kwarg called lines=. I am a reluctant to do it this way because it then means there are two ways to pass data into make_addplot() ... through the data variable, or through the lines variable.

If we want make_addplot() to call the conversion function internally, then I would pass the list of date,price tuples into make_addplot() where the data is normally passed. Then we either add a kwarg sparsedata=True to tell make_addplot() to call the converter, or perhaps make_addplot() can figure out on its own that the data it received is a list of date,price tuples (and decide to call the converter).

What do you think?

As I am writing this, I am beginning to like the last proposal the best:
make_addplot() can simply accept a sparse list of date,price tuples (in same data variable where it normally accepts the full list of data). It detects this situation, and calls the converter to convert the sparse list into a full list with prices and NaN values in the correct places. It then places the converted data into the dict that it returns.

---

Correction:
I just realized there is one thing missing above. Conversion of the sparse list of date,price tuples, to a series with the same datetime index as the dataframe needs also the datetime index, or the list of dates from the datetime index as input to the conversion function. Therefore it may make sense to call the conversion function from within mpf.plot() because that function already has the datetime index available. I also did some playing around with this code, and it appears that addplot will not plot the values as lines, rather only as a scatter plot, unless we [linearly] interpolate missing values (the values between the specified date,price tuples).

[thegamecat]

Can't it work the same as plt so:
mpf.scatter(trade_list_idx,trade_list_price,c='b')
mpf.plot(pr1, c='r')
mpf.plot(hsr1, c='b')
mpf.plot(lsr1, c='y')

[DanielGoldfarb]

@thegamecat

I have no idea what you are trying to say with:

Can't it work the same as plt so:
mpf.scatter(trade_list_idx,trade_list_price,c='b')
mpf.plot(pr1, c='r')
mpf.plot(hsr1, c='b')
mpf.plot(lsr1, c='y')

This present issue is about plotting trend lines (not a scatter plot of trades).

[DanielGoldfarb]

@dattran2346
I think I have a way to make this as simple as you proposed. Something like this:

ap = mpf.make_addplot( [(dateA, priceA), (dateB, priceB), (dateC, priceC), ...] )
mpf.plot( df, addplot=ap)

Will keep you posted. Have a couple other things to finish up first.

[DanielGoldfarb]

just a note, so I don't forget; i am thinking of implementing this as a LineCollection and, internally, the same implementation could be used for issue #54