#ifndef FINANCECHART_HDR
|
#define FINANCECHART_HDR
|
|
#include "chartdir.h"
|
#include <math.h>
|
#include <stdio.h>
|
#include <string.h>
|
#include <string>
|
#include <vector>
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
// Copyright 2012 Advanced Software Engineering Limited
|
//
|
// ChartDirector FinanceChart class library
|
// - Requires ChartDirector Ver 5.1 or above
|
//
|
// You may use and modify the code in this file in your application, provided the code and
|
// its modifications are used only in conjunction with ChartDirector. Usage of this software
|
// is subjected to the terms and condition of the ChartDirector license.
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
#ifdef _MSC_VER
|
#pragma warning(push)
|
#pragma warning(disable:4996)
|
#endif
|
|
/// <summary>
|
/// Represents a Financial Chart
|
/// </summary>
|
class FinanceChart : public MultiChart
|
{
|
int m_totalWidth;
|
int m_totalHeight;
|
bool m_antiAlias;
|
bool m_logScale;
|
bool m_axisOnRight;
|
|
int m_leftMargin;
|
int m_rightMargin;
|
int m_topMargin;
|
int m_bottomMargin;
|
|
int m_plotAreaBgColor;
|
int m_plotAreaBorder;
|
int m_plotAreaGap;
|
|
int m_majorHGridColor;
|
int m_minorHGridColor;
|
int m_majorVGridColor;
|
int m_minorVGridColor;
|
|
std::string m_legendFont;
|
double m_legendFontSize;
|
int m_legendFontColor;
|
int m_legendBgColor;
|
|
std::string m_yAxisFont;
|
double m_yAxisFontSize;
|
int m_yAxisFontColor;
|
int m_yAxisMargin;
|
|
std::string m_xAxisFont;
|
double m_xAxisFontSize;
|
int m_xAxisFontColor;
|
double m_xAxisFontAngle;
|
|
DoubleArray m_timeStamps;
|
DoubleArray m_highData;
|
DoubleArray m_lowData;
|
DoubleArray m_openData;
|
DoubleArray m_closeData;
|
DoubleArray m_volData;
|
std::string m_volUnit;
|
int m_extraPoints;
|
|
std::string m_yearFormat;
|
std::string m_firstMonthFormat;
|
std::string m_otherMonthFormat;
|
std::string m_firstDayFormat;
|
std::string m_otherDayFormat;
|
std::string m_firstHourFormat;
|
std::string m_otherHourFormat;
|
int m_timeLabelSpacing;
|
|
std::string m_generalFormat;
|
|
std::string m_toolTipMonthFormat;
|
std::string m_toolTipDayFormat;
|
std::string m_toolTipHourFormat;
|
|
XYChart *m_mainChart;
|
XYChart *m_currentChart;
|
std::vector<XYChart *> garbage;
|
|
private: void init()
|
{
|
m_totalWidth = 0;
|
m_totalHeight = 0;
|
m_antiAlias = true;
|
m_logScale = false;
|
m_axisOnRight = true;
|
|
m_leftMargin = 40;
|
m_rightMargin = 40;
|
m_topMargin = 30;
|
m_bottomMargin = 35;
|
|
m_plotAreaBgColor = 0xffffff;
|
m_plotAreaBorder = 0x888888;
|
m_plotAreaGap = 2;
|
|
m_majorHGridColor = 0xdddddd;
|
m_minorHGridColor = 0xdddddd;
|
m_majorVGridColor = 0xdddddd;
|
m_minorVGridColor = 0xdddddd;
|
|
m_legendFont = "normal";
|
m_legendFontSize = 8;
|
m_legendFontColor = Chart::TextColor;
|
m_legendBgColor = 0x80cccccc;
|
|
m_yAxisFont = "normal";
|
m_yAxisFontSize = 8;
|
m_yAxisFontColor = Chart::TextColor;
|
m_yAxisMargin = 14;
|
|
m_xAxisFont = "normal";
|
m_xAxisFontSize = 8;
|
m_xAxisFontColor = Chart::TextColor;
|
m_xAxisFontAngle = 0;
|
|
m_volUnit = "";
|
m_extraPoints = 0;
|
|
m_yearFormat = "{value|yyyy}";
|
m_firstMonthFormat = "<*font=bold*>{value|mmm yy}";
|
m_otherMonthFormat = "{value|mmm}";
|
m_firstDayFormat = "<*font=bold*>{value|d mmm}";
|
m_otherDayFormat = "{value|d}";
|
m_firstHourFormat = "<*font=bold*>{value|d mmm\nh:nna}";
|
m_otherHourFormat = "{value|h:nna}";
|
m_timeLabelSpacing = 50;
|
|
m_generalFormat = "P3";
|
|
m_toolTipMonthFormat = "[{xLabel|mmm yyyy}]";
|
m_toolTipDayFormat = "[{xLabel|mmm d, yyyy}]";
|
m_toolTipHourFormat = "[{xLabel|mmm d, yyyy hh:nn:ss}]";
|
|
m_mainChart = 0;
|
m_currentChart = 0;
|
}
|
|
/// <summary>
|
/// Create a FinanceChart with a given width. The height will be automatically determined
|
/// as the chart is built.
|
/// </summary>
|
/// <param name="width">Width of the chart in pixels</param>
|
public: FinanceChart(int width): MultiChart(width, 1)
|
{
|
init();
|
m_totalWidth = width;
|
setMainChart(this);
|
}
|
|
// free resources
|
public: ~FinanceChart()
|
{
|
delete[] const_cast<double *>(m_timeStamps.data);
|
delete[] const_cast<double *>(m_highData.data);
|
delete[] const_cast<double *>(m_lowData.data);
|
delete[] const_cast<double *>(m_openData.data);
|
delete[] const_cast<double *>(m_closeData.data);
|
delete[] const_cast<double *>(m_volData.data);
|
|
for (int i = 0; i < (int)garbage.size(); ++i)
|
delete garbage[i];
|
}
|
|
// disable copying
|
private: FinanceChart(const FinanceChart &rhs);
|
private: FinanceChart &operator=(const FinanceChart &rhs);
|
|
/// <summary>
|
/// Enable/Disable anti-alias. Enabling anti-alias makes the line smoother. Disabling
|
/// anti-alias make the chart file size smaller, and so can be downloaded faster
|
/// through the Internet. The default is to enable anti-alias.
|
/// </summary>
|
/// <param name="antiAlias">True to enable anti-alias. False to disable anti-alias.</param>
|
public: void enableAntiAlias(bool antiAlias)
|
{
|
m_antiAlias = antiAlias;
|
}
|
|
/// <summary>
|
/// Set the margins around the plot area.
|
/// </summary>
|
/// <param name="m_leftMargin">The distance between the plot area and the chart left edge.</param>
|
/// <param name="m_topMargin">The distance between the plot area and the chart top edge.</param>
|
/// <param name="m_rightMargin">The distance between the plot area and the chart right edge.</param>
|
/// <param name="m_bottomMargin">The distance between the plot area and the chart bottom edge.</param>
|
public: void setMargins(int leftMargin, int topMargin, int rightMargin, int bottomMargin)
|
{
|
m_leftMargin = leftMargin;
|
m_rightMargin = rightMargin;
|
m_topMargin = topMargin;
|
m_bottomMargin = bottomMargin;
|
}
|
|
/// <summary>
|
/// Add a text title above the plot area. You may add multiple title above the plot area by
|
/// calling this method multiple times.
|
/// </summary>
|
/// <param name="alignment">The alignment with respect to the region that is on top of the
|
/// plot area.</param>
|
/// <param name="text">The text to add.</param>
|
/// <returns>The TextBox object representing the text box above the plot area.</returns>
|
public: TextBox* addPlotAreaTitle(int alignment, const char* text)
|
{
|
TextBox *ret = addText(m_leftMargin, 0, text, "bold", 10, Chart::TextColor, alignment);
|
ret->setSize(m_totalWidth - m_leftMargin - m_rightMargin + 1, m_topMargin - 1);
|
ret->setMargin(0);
|
return ret;
|
}
|
|
/// <summary>
|
/// Set the plot area style. The default is to use pale yellow 0xfffff0 as the background,
|
/// and light grey 0xdddddd as the grid lines.
|
/// </summary>
|
/// <param name="bgColor">The plot area background color.</param>
|
/// <param name="majorHGridColor">Major horizontal grid color.</param>
|
/// <param name="majorVGridColor">Major vertical grid color.</param>
|
/// <param name="minorHGridColor">Minor horizontal grid color. In current version, minor
|
/// horizontal grid is not used.</param>
|
/// <param name="minorVGridColor">Minor vertical grid color.</param>
|
public: void setPlotAreaStyle(int bgColor, int majorHGridColor, int majorVGridColor,
|
int minorHGridColor, int minorVGridColor)
|
{
|
m_plotAreaBgColor = bgColor;
|
m_majorHGridColor = majorHGridColor;
|
m_majorVGridColor = majorVGridColor;
|
m_minorHGridColor = minorHGridColor;
|
m_minorVGridColor = minorVGridColor;
|
}
|
|
/// <summary>
|
/// Set the plot area border style. The default is grey color (888888), with a gap
|
/// of 2 pixels between charts.
|
/// </summary>
|
/// <param name="borderColor">The color of the border.</param>
|
/// <param name="borderGap">The gap between two charts.</param>
|
public: void setPlotAreaBorder(int borderColor, int borderGap)
|
{
|
m_plotAreaBorder = borderColor;
|
m_plotAreaGap = borderGap;
|
}
|
|
/// <summary>
|
/// Set legend style. The default is Arial 8 pt black color, with light grey background.
|
/// </summary>
|
/// <param name="font">The font of the legend text.</param>
|
/// <param name="fontSize">The font size of the legend text in points.</param>
|
/// <param name="fontColor">The color of the legend text.</param>
|
/// <param name="bgColor">The background color of the legend box.</param>
|
public: void setLegendStyle(const char* font, double fontSize, int fontColor, int bgColor)
|
{
|
m_legendFont = font;
|
m_legendFontSize = fontSize;
|
m_legendFontColor = fontColor;
|
m_legendBgColor = bgColor;
|
}
|
|
/// <summary>
|
/// Set x-axis label style. The default is Arial 8 pt black color no rotation.
|
/// </summary>
|
/// <param name="font">The font of the axis labels.</param>
|
/// <param name="fontSize">The font size of the axis labels in points.</param>
|
/// <param name="fontColor">The color of the axis labels.</param>
|
/// <param name="fontAngle">The rotation of the axis labels.</param>
|
public: void setXAxisStyle(const char* font, double fontSize, int fontColor, double fontAngle)
|
{
|
m_xAxisFont = font;
|
m_xAxisFontSize = fontSize;
|
m_xAxisFontColor = fontColor;
|
m_xAxisFontAngle = fontAngle;
|
}
|
|
/// <summary>
|
/// Set y-axis label style. The default is Arial 8 pt black color, with 13 pixels margin.
|
/// </summary>
|
/// <param name="font">The font of the axis labels.</param>
|
/// <param name="fontSize">The font size of the axis labels in points.</param>
|
/// <param name="fontColor">The color of the axis labels.</param>
|
/// <param name="axisMargin">The margin at the top of the y-axis in pixels (to leave
|
/// space for the legend box).</param>
|
public: void setYAxisStyle(const char* font, double fontSize, int fontColor, int axisMargin)
|
{
|
m_yAxisFont = font;
|
m_yAxisFontSize = fontSize;
|
m_yAxisFontColor = fontColor;
|
m_yAxisMargin = axisMargin;
|
}
|
|
/// <summary>
|
/// Set whether the main y-axis is on right of left side of the plot area. The default is
|
/// on right.
|
/// </summary>
|
/// <param name="b">True if the y-axis is on right. False if the y-axis is on left.</param>
|
public: void setAxisOnRight(bool b)
|
{
|
m_axisOnRight = b;
|
}
|
|
/// <summary>
|
/// Determines if log scale should be used for the main chart. The default is linear scale.
|
/// </summary>
|
/// <param name="b">True for using log scale. False for using linear scale.</param>
|
public: void setLogScale(bool b)
|
{
|
m_logScale = b;
|
if (m_mainChart != 0) {
|
if (m_logScale) {
|
m_mainChart->yAxis()->setLogScale();
|
} else {
|
m_mainChart->yAxis()->setLinearScale();
|
}
|
}
|
}
|
|
/// <summary>
|
/// Set the date/time formats to use for the x-axis labels under various cases.
|
/// </summary>
|
/// <param name="yearFormat">The format for displaying labels on an axis with yearly ticks. The
|
/// default is "yyyy".</param>
|
/// <param name="firstMonthFormat">The format for displaying labels on an axis with monthly ticks.
|
/// This parameter applies to the first available month of a year (usually January) only, so it can
|
/// be formatted differently from the other labels.</param>
|
/// <param name="otherMonthFormat">The format for displaying labels on an axis with monthly ticks.
|
/// This parameter applies to months other than the first available month of a year.</param>
|
/// <param name="firstDayFormat">The format for displaying labels on an axis with daily ticks.
|
/// This parameter applies to the first available day of a month only, so it can be formatted
|
/// differently from the other labels.</param>
|
/// <param name="otherDayFormat">The format for displaying labels on an axis with daily ticks.
|
/// This parameter applies to days other than the first available day of a month.</param>
|
/// <param name="firstHourFormat">The format for displaying labels on an axis with hourly
|
/// resolution. This parameter applies to the first tick of a day only, so it can be formatted
|
/// differently from the other labels.</param>
|
/// <param name="otherHourFormat">The format for displaying labels on an axis with hourly.
|
/// resolution. This parameter applies to ticks at hourly boundaries, except the first tick
|
/// of a day.</param>
|
public: void setDateLabelFormat(const char* yearFormat, const char* firstMonthFormat,
|
const char* otherMonthFormat, const char* firstDayFormat, const char* otherDayFormat,
|
const char* firstHourFormat, const char* otherHourFormat)
|
{
|
if (yearFormat != 0) {
|
m_yearFormat = yearFormat;
|
}
|
if (firstMonthFormat != 0) {
|
m_firstMonthFormat = firstMonthFormat;
|
}
|
if (otherMonthFormat != 0) {
|
m_otherMonthFormat = otherMonthFormat;
|
}
|
if (firstDayFormat != 0) {
|
m_firstDayFormat = firstDayFormat;
|
}
|
if (otherDayFormat != 0) {
|
m_otherDayFormat = otherDayFormat;
|
}
|
if (firstHourFormat != 0) {
|
m_firstHourFormat = firstHourFormat;
|
}
|
if (otherHourFormat != 0) {
|
m_otherHourFormat = otherHourFormat;
|
}
|
}
|
|
/// <summary>
|
/// Set the minimum label spacing between two labels on the time axis
|
/// </summary>
|
/// <param name="labelSpacing">The minimum label spacing in pixels.</param>
|
public: void setDateLabelSpacing(int labelSpacing)
|
{
|
if (labelSpacing > 0) {
|
m_timeLabelSpacing = labelSpacing;
|
} else {
|
m_timeLabelSpacing = 0;
|
}
|
}
|
|
/// <summary>
|
/// Set the tool tip formats for display date/time
|
/// </summary>
|
/// <param name="monthFormat">The tool tip format to use if the data point spacing is one
|
/// or more months (more than 30 days).</param>
|
/// <param name="dayFormat">The tool tip format to use if the data point spacing is 1 day
|
/// to less than 30 days.</param>
|
/// <param name="hourFormat">The tool tip format to use if the data point spacing is less
|
/// than 1 day.</param>
|
public: void setToolTipDateFormat(const char* monthFormat, const char* dayFormat,
|
const char* hourFormat)
|
{
|
if (monthFormat != 0) {
|
m_toolTipMonthFormat = monthFormat;
|
}
|
if (dayFormat != 0) {
|
m_toolTipDayFormat = dayFormat;
|
}
|
if (hourFormat != 0) {
|
m_toolTipHourFormat = hourFormat;
|
}
|
}
|
|
/// <summary>
|
/// Get the tool tip format for display date/time
|
/// </summary>
|
/// <returns>The tool tip format string.</returns>
|
public: const char *getToolTipDateFormat()
|
{
|
if (m_timeStamps.len == 0) {
|
return m_toolTipHourFormat.c_str();
|
}
|
if (m_timeStamps.len <= m_extraPoints) {
|
return m_toolTipHourFormat.c_str();
|
}
|
double resolution = (m_timeStamps[m_timeStamps.len - 1] -
|
m_timeStamps[0]) / m_timeStamps.len;
|
if (resolution >= 30 * 86400) {
|
return m_toolTipMonthFormat.c_str();
|
} else if (resolution >= 86400) {
|
return m_toolTipDayFormat.c_str();
|
} else {
|
return m_toolTipHourFormat.c_str();
|
}
|
}
|
|
/// <summary>
|
/// Set the number format for use in displaying values in legend keys and tool tips.
|
/// </summary>
|
/// <param name="formatString">The default number format.</param>
|
public: void setNumberLabelFormat(const char* formatString)
|
{
|
if (formatString != 0) {
|
m_generalFormat = formatString;
|
}
|
}
|
|
/// <summary>
|
/// A utility function to compute triangular moving averages
|
/// </summary>
|
/// <param name="data">An array of numbers as input.</param>
|
/// <param name="period">The moving average period.</param>
|
/// <returns>An array representing the triangular moving average of the input array.</returns>
|
private: ArrayMath computeTriMovingAvg(DoubleArray data, int period)
|
{
|
int p = period / 2 + 1;
|
return ArrayMath(data).movAvg(p).movAvg(p);
|
}
|
|
/// <summary>
|
/// A utility function to compute weighted moving averages
|
/// </summary>
|
/// <param name="data">An array of numbers as input.</param>
|
/// <param name="period">The moving average period.</param>
|
/// <returns>An array representing the weighted moving average of the input array.</returns>
|
private: ArrayMath computeWeightedMovingAvg(DoubleArray data, int period)
|
{
|
ArrayMath acc(data);
|
int i;
|
for(i = 2; i < period + 1; ++i) {
|
acc.add(ArrayMath(data).movAvg(i).mul(i));
|
}
|
return acc.div((1 + period) * period / 2);
|
}
|
|
/// <summary>
|
/// A utility function to obtain the first visible closing price.
|
/// </summary>
|
/// <returns>The first closing price.
|
/// are cd.NoValue.</returns>
|
private: double firstCloseValue()
|
{
|
for(int i = m_extraPoints; i < m_closeData.len; ++i) {
|
if ((m_closeData[i] != Chart::NoValue) && (m_closeData[i] != 0)) {
|
return m_closeData[i];
|
}
|
}
|
return Chart::NoValue;
|
}
|
|
/// <summary>
|
/// A utility function to obtain the last valid position (that is, position not
|
/// containing cd.NoValue) of a data series.
|
/// </summary>
|
/// <param name="data">An array of numbers as input.</param>
|
/// <returns>The last valid position in the input array, or -1 if all positions
|
/// are cd.NoValue.</returns>
|
private: int lastIndex(DoubleArray data)
|
{
|
int i = data.len - 1;
|
while (i >= 0) {
|
if (data[i] != Chart::NoValue) {
|
break;
|
}
|
i = i - 1;
|
}
|
return i;
|
}
|
|
//deep copy array
|
private: void deepCopy(DoubleArray &dest, DoubleArray src)
|
{
|
if (src.len > dest.len)
|
{
|
delete[] const_cast<double *>(dest.data);
|
dest.data = new double[src.len];
|
}
|
memcpy(const_cast<double *>(dest.data), src.data, src.len * sizeof(double));
|
dest.len = src.len;
|
}
|
|
/// <summary>
|
/// Set the data used in the chart. If some of the data are not available, some artifical
|
/// values should be used. For example, if the high and low values are not available, you
|
/// may use closeData as highData and lowData.
|
/// </summary>
|
/// <param name="timeStamps">An array of dates/times for the time intervals.</param>
|
/// <param name="highData">The high values in the time intervals.</param>
|
/// <param name="lowData">The low values in the time intervals.</param>
|
/// <param name="openData">The open values in the time intervals.</param>
|
/// <param name="closeData">The close values in the time intervals.</param>
|
/// <param name="volData">The volume values in the time intervals.</param>
|
/// <param name="extraPoints">The number of leading time intervals that are not
|
/// displayed in the chart. These intervals are typically used for computing
|
/// indicators that require extra leading data, such as moving averages.</param>
|
public: void setData(DoubleArray timeStamps, DoubleArray highData, DoubleArray lowData,
|
DoubleArray openData, DoubleArray closeData, DoubleArray volData, int extraPoints)
|
{
|
deepCopy(m_timeStamps, timeStamps);
|
deepCopy(m_highData, highData);
|
deepCopy(m_lowData, lowData);
|
deepCopy(m_openData, openData);
|
deepCopy(m_closeData, closeData);
|
if (extraPoints > 0) {
|
m_extraPoints = extraPoints;
|
} else {
|
m_extraPoints = 0;
|
}
|
|
/////////////////////////////////////////////////////////////////////////
|
// Auto-detect volume units
|
/////////////////////////////////////////////////////////////////////////
|
double maxVol = ArrayMath(volData).maxValue();
|
const char *units[] = {"", "K", "M", "B"};
|
int unitIndex = sizeof(units) / sizeof(units[0]) - 1;
|
while ((unitIndex > 0) && (maxVol < pow(1000.0, unitIndex))) {
|
unitIndex = unitIndex - 1;
|
}
|
|
deepCopy(m_volData, ArrayMath(volData).div(pow(1000.0, unitIndex)));
|
m_volUnit = units[unitIndex];
|
}
|
|
//////////////////////////////////////////////////////////////////////////////
|
// Format x-axis labels
|
//////////////////////////////////////////////////////////////////////////////
|
private: void setXLabels(Axis* a)
|
{
|
a->setLabels(m_timeStamps);
|
if (m_extraPoints < m_timeStamps.len) {
|
int tickStep = (m_timeStamps.len - m_extraPoints) *
|
m_timeLabelSpacing / (m_totalWidth - m_leftMargin - m_rightMargin) + 1;
|
double timeRangeInSeconds = m_timeStamps[m_timeStamps.len
|
- 1] - m_timeStamps[m_extraPoints];
|
double secondsBetweenTicks = timeRangeInSeconds / (m_totalWidth - m_leftMargin -
|
m_rightMargin) * m_timeLabelSpacing;
|
|
if (secondsBetweenTicks * (m_timeStamps.len - m_extraPoints) <= timeRangeInSeconds) {
|
tickStep = 1;
|
if (m_timeStamps.len > 1)
|
secondsBetweenTicks = m_timeStamps[m_timeStamps.len - 1] - m_timeStamps[m_timeStamps.len - 2];
|
else
|
secondsBetweenTicks = 86400;
|
}
|
|
if ((secondsBetweenTicks > 360 * 86400) || ((secondsBetweenTicks > 90 * 86400) && (timeRangeInSeconds >= 720 * 86400))) {
|
//yearly ticks
|
a->setMultiFormat(Chart::StartOfYearFilter(), m_yearFormat.c_str(), tickStep);
|
} else if ((secondsBetweenTicks >= 30 * 86400) || ((secondsBetweenTicks > 7 * 86400) && (timeRangeInSeconds >= 60 * 86400))) {
|
//monthly ticks
|
int monthBetweenTicks = (int)(secondsBetweenTicks / 31 / 86400) + 1;
|
a->setMultiFormat(Chart::StartOfYearFilter(), m_firstMonthFormat.c_str(),
|
Chart::StartOfMonthFilter(monthBetweenTicks), m_otherMonthFormat.c_str());
|
a->setMultiFormat(Chart::StartOfMonthFilter(), "-", 1, false);
|
} else if ((secondsBetweenTicks >= 86400) || ((secondsBetweenTicks > 6 * 3600) & (timeRangeInSeconds >= 86400))) {
|
//daily ticks
|
a->setMultiFormat(Chart::StartOfMonthFilter(), m_firstDayFormat.c_str(),
|
Chart::StartOfDayFilter(1, 0.5), m_otherDayFormat.c_str(), tickStep);
|
} else {
|
//hourly ticks
|
a->setMultiFormat(Chart::StartOfDayFilter(1, 0.5), m_firstHourFormat.c_str(),
|
Chart::StartOfHourFilter(1, 0.5), m_otherHourFormat.c_str(), tickStep);
|
}
|
}
|
}
|
|
//////////////////////////////////////////////////////////////////////////////
|
// Create tool tip format string for showing OHLC data
|
//////////////////////////////////////////////////////////////////////////////
|
private: std::string getHLOCToolTipFormat()
|
{
|
char buffer[1024];
|
sprintf(buffer, "title='%s Op:{open|%s}, Hi:{high|%s}, Lo:{low|%s}, Cl:{close|%s}'",
|
getToolTipDateFormat(), m_generalFormat.c_str(), m_generalFormat.c_str(), m_generalFormat.c_str(),
|
m_generalFormat.c_str());
|
return buffer;
|
}
|
|
/// <summary>
|
/// Add the main chart - the chart that shows the HLOC data.
|
/// </summary>
|
/// <param name="height">The height of the main chart in pixels.</param>
|
/// <returns>An XYChart object representing the main chart created.</returns>
|
public: XYChart* addMainChart(int height)
|
{
|
m_mainChart = addIndicator(height);
|
m_mainChart->yAxis()->setMargin(2 * m_yAxisMargin);
|
if (m_logScale) {
|
m_mainChart->yAxis()->setLogScale();
|
} else {
|
m_mainChart->yAxis()->setLinearScale();
|
}
|
return m_mainChart;
|
}
|
|
/// <summary>
|
/// Add a candlestick layer to the main chart.
|
/// </summary>
|
/// <param name="upColor">The candle color for an up day.</param>
|
/// <param name="downColor">The candle color for a down day.</param>
|
/// <returns>The CandleStickLayer created.</returns>
|
public: CandleStickLayer* addCandleStick(int upColor, int downColor)
|
{
|
addOHLCLabel(upColor, downColor, true);
|
CandleStickLayer *ret = m_mainChart->addCandleStickLayer(m_highData, m_lowData, m_openData,
|
m_closeData, upColor, downColor);
|
ret->setHTMLImageMap("", "", getHLOCToolTipFormat().c_str());
|
if (m_highData.len - m_extraPoints > 60) {
|
ret->setDataGap(0);
|
}
|
|
if (m_highData.len > m_extraPoints) {
|
int expectedWidth = (m_totalWidth - m_leftMargin - m_rightMargin) / (m_highData.len - m_extraPoints);
|
if (expectedWidth <= 5)
|
ret->setDataWidth(expectedWidth + 1 - expectedWidth % 2);
|
}
|
|
return ret;
|
}
|
|
/// <summary>
|
/// Add a HLOC layer to the main chart.
|
/// </summary>
|
/// <param name="upColor">The color of the HLOC symbol for an up day.</param>
|
/// <param name="downColor">The color of the HLOC symbol for a down day.</param>
|
/// <returns>The HLOCLayer created.</returns>
|
public: HLOCLayer* addHLOC(int upColor, int downColor)
|
{
|
addOHLCLabel(upColor, downColor, false);
|
HLOCLayer *ret = m_mainChart->addHLOCLayer(m_highData, m_lowData, m_openData, m_closeData);
|
ret->setColorMethod(Chart::HLOCUpDown, upColor, downColor);
|
ret->setHTMLImageMap("", "", getHLOCToolTipFormat().c_str());
|
ret->setDataGap(0);
|
return ret;
|
}
|
|
private: void addOHLCLabel(int upColor, int downColor, bool candleStickMode)
|
{
|
int i = lastIndex(m_closeData);
|
if (i >= 0) {
|
double openValue = Chart::NoValue;
|
double closeValue = Chart::NoValue;
|
double highValue = Chart::NoValue;
|
double lowValue = Chart::NoValue;
|
|
if (i < m_openData.len) {
|
openValue = m_openData[i];
|
}
|
if (i < m_closeData.len) {
|
closeValue = m_closeData[i];
|
}
|
if (i < m_highData.len) {
|
highValue = m_highData[i];
|
}
|
if (i < m_lowData.len) {
|
lowValue = m_lowData[i];
|
}
|
|
std::string openLabel = "";
|
std::string closeLabel = "";
|
std::string highLabel = "";
|
std::string lowLabel = "";
|
const char *delim = "";
|
char buffer[1024];
|
|
if (openValue != Chart::NoValue) {
|
sprintf(buffer, "Op:%s", formatValue(openValue, m_generalFormat.c_str()));
|
openLabel = buffer;
|
delim = ", ";
|
}
|
if (highValue != Chart::NoValue) {
|
sprintf(buffer, "%sHi:%s", delim, formatValue(highValue, m_generalFormat.c_str()));
|
highLabel = buffer;
|
delim = ", ";
|
}
|
if (lowValue != Chart::NoValue) {
|
sprintf(buffer, "%sLo:%s", delim, formatValue(lowValue, m_generalFormat.c_str()));
|
lowLabel = buffer;
|
delim = ", ";
|
}
|
if (closeValue != Chart::NoValue) {
|
sprintf(buffer, "%sCl:%s", delim, formatValue(closeValue, m_generalFormat.c_str()));
|
closeLabel = buffer;
|
delim = ", ";
|
}
|
std::string label = openLabel + highLabel + lowLabel + closeLabel;
|
|
bool useUpColor = (closeValue >= openValue);
|
if (candleStickMode != true) {
|
ArrayMath closeChanges = ArrayMath(m_closeData).delta();
|
int lastChangeIndex = lastIndex(closeChanges);
|
useUpColor = (lastChangeIndex < 0);
|
if (useUpColor != true) {
|
useUpColor = (closeChanges.result()[lastChangeIndex] >= 0);
|
}
|
}
|
|
int udcolor = downColor;
|
if (useUpColor) {
|
udcolor = upColor;
|
}
|
m_mainChart->getLegend()->addKey(label.c_str(), udcolor);
|
}
|
}
|
|
/// <summary>
|
/// Add a closing price line on the main chart.
|
/// </summary>
|
/// <param name="color">The color of the line.</param>
|
/// <returns>The LineLayer object representing the line created.</returns>
|
public: LineLayer* addCloseLine(int color)
|
{
|
return addLineIndicator2(m_mainChart, m_closeData, color, "Closing Price");
|
}
|
|
/// <summary>
|
/// Add a weight close line on the main chart.
|
/// </summary>
|
/// <param name="color">The color of the line.</param>
|
/// <returns>The LineLayer object representing the line created.</returns>
|
public: LineLayer* addWeightedClose(int color)
|
{
|
return addLineIndicator2(m_mainChart, ArrayMath(m_highData).add(m_lowData).add(m_closeData
|
).add(m_closeData).div(4), color, "Weighted Close");
|
}
|
|
/// <summary>
|
/// Add a typical price line on the main chart.
|
/// </summary>
|
/// <param name="color">The color of the line.</param>
|
/// <returns>The LineLayer object representing the line created.</returns>
|
public: LineLayer* addTypicalPrice(int color)
|
{
|
return addLineIndicator2(m_mainChart, ArrayMath(m_highData).add(m_lowData).add(m_closeData
|
).div(3), color, "Typical Price");
|
}
|
|
/// <summary>
|
/// Add a median price line on the main chart.
|
/// </summary>
|
/// <param name="color">The color of the line.</param>
|
/// <returns>The LineLayer object representing the line created.</returns>
|
public: LineLayer* addMedianPrice(int color)
|
{
|
return addLineIndicator2(m_mainChart, ArrayMath(m_highData).add(m_lowData).div(2), color,
|
"Median Price");
|
}
|
|
/// <summary>
|
/// Add a simple moving average line on the main chart.
|
/// </summary>
|
/// <param name="period">The moving average period</param>
|
/// <param name="color">The color of the line.</param>
|
/// <returns>The LineLayer object representing the line created.</returns>
|
public: LineLayer* addSimpleMovingAvg(int period, int color)
|
{
|
char buffer[1024];
|
sprintf(buffer, "SMA (%d)", period);
|
return addLineIndicator2(m_mainChart, ArrayMath(m_closeData).movAvg(period), color, buffer);
|
}
|
|
/// <summary>
|
/// Add an exponential moving average line on the main chart.
|
/// </summary>
|
/// <param name="period">The moving average period</param>
|
/// <param name="color">The color of the line.</param>
|
/// <returns>The LineLayer object representing the line created.</returns>
|
public: LineLayer* addExpMovingAvg(int period, int color)
|
{
|
char buffer[1024];
|
sprintf(buffer, "EMA (%d)", period);
|
return addLineIndicator2(m_mainChart, ArrayMath(m_closeData).expAvg(2.0 / (period + 1)),
|
color, buffer);
|
}
|
|
/// <summary>
|
/// Add a triangular moving average line on the main chart.
|
/// </summary>
|
/// <param name="period">The moving average period</param>
|
/// <param name="color">The color of the line.</param>
|
/// <returns>The LineLayer object representing the line created.</returns>
|
public: LineLayer* addTriMovingAvg(int period, int color)
|
{
|
char buffer[1024];
|
sprintf(buffer, "TMA (%d)", period);
|
return addLineIndicator2(m_mainChart, computeTriMovingAvg(m_closeData, period),
|
color, buffer);
|
}
|
|
/// <summary>
|
/// Add a weighted moving average line on the main chart.
|
/// </summary>
|
/// <param name="period">The moving average period</param>
|
/// <param name="color">The color of the line.</param>
|
/// <returns>The LineLayer object representing the line created.</returns>
|
public: LineLayer* addWeightedMovingAvg(int period, int color)
|
{
|
char buffer[1024];
|
sprintf(buffer, "WMA (%d)", period);
|
return addLineIndicator2(m_mainChart, computeWeightedMovingAvg(m_closeData, period
|
), color, buffer);
|
}
|
|
/// <summary>
|
/// Add a parabolic SAR indicator to the main chart.
|
/// </summary>
|
/// <param name="accInitial">Initial acceleration factor</param>
|
/// <param name="accIncrement">Acceleration factor increment</param>
|
/// <param name="accMaximum">Maximum acceleration factor</param>
|
/// <param name="symbolType">The symbol used to plot the parabolic SAR</param>
|
/// <param name="symbolSize">The symbol size in pixels</param>
|
/// <param name="fillColor">The fill color of the symbol</param>
|
/// <param name="edgeColor">The edge color of the symbol</param>
|
/// <returns>The LineLayer object representing the layer created.</returns>
|
public: LineLayer* addParabolicSAR(double accInitial, double accIncrement, double accMaximum,
|
int symbolType, int symbolSize, int fillColor, int edgeColor)
|
{
|
bool isLong = true;
|
double acc = accInitial;
|
double extremePoint = 0;
|
double *psar = new double[m_lowData.len];
|
|
int i_1 = -1;
|
int i_2 = -1;
|
|
for(int i = 0; i < m_lowData.len; ++i) {
|
psar[i] = Chart::NoValue;
|
if ((m_lowData[i] != Chart::NoValue) && (m_highData[i] != Chart::NoValue)) {
|
if ((i_1 >= 0) && (i_2 < 0)) {
|
if (m_lowData[i_1] <= m_lowData[i]) {
|
psar[i] = m_lowData[i_1];
|
isLong = true;
|
if (m_highData[i_1] > m_highData[i]) {
|
extremePoint = m_highData[i_1];
|
} else {
|
extremePoint = m_highData[i];
|
}
|
} else {
|
extremePoint = m_lowData[i];
|
isLong = false;
|
if (m_highData[i_1] > m_highData[i]) {
|
psar[i] = m_highData[i_1];
|
} else {
|
psar[i] = m_highData[i];
|
}
|
}
|
} else if ((i_1 >= 0) && (i_2 >= 0)) {
|
if (acc > accMaximum) {
|
acc = accMaximum;
|
}
|
|
psar[i] = psar[i_1] + acc * (extremePoint - psar[i_1]);
|
|
if (isLong) {
|
if (m_lowData[i] < psar[i]) {
|
isLong = false;
|
psar[i] = extremePoint;
|
extremePoint = m_lowData[i];
|
acc = accInitial;
|
} else {
|
if (m_highData[i] > extremePoint) {
|
extremePoint = m_highData[i];
|
acc = acc + accIncrement;
|
}
|
|
if (m_lowData[i_1] < psar[i]) {
|
psar[i] = m_lowData[i_1];
|
}
|
if (m_lowData[i_2] < psar[i]) {
|
psar[i] = m_lowData[i_2];
|
}
|
}
|
} else {
|
if (m_highData[i] > psar[i]) {
|
isLong = true;
|
psar[i] = extremePoint;
|
extremePoint = m_highData[i];
|
acc = accInitial;
|
} else {
|
if (m_lowData[i] < extremePoint) {
|
extremePoint = m_lowData[i];
|
acc = acc + accIncrement;
|
}
|
|
if (m_highData[i_1] > psar[i]) {
|
psar[i] = m_highData[i_1];
|
}
|
if (m_highData[i_2] > psar[i]) {
|
psar[i] = m_highData[i_2];
|
}
|
}
|
}
|
}
|
|
i_2 = i_1;
|
i_1 = i;
|
}
|
}
|
|
LineLayer* ret = addLineIndicator2(m_mainChart, DoubleArray(psar, m_lowData.len),
|
fillColor, "Parabolic SAR");
|
ret->setLineWidth(0);
|
|
ret = addLineIndicator2(m_mainChart, DoubleArray(psar, m_lowData.len), fillColor, "");
|
ret->setLineWidth(0);
|
ret->getDataSet(0)->setDataSymbol(symbolType, symbolSize, fillColor, edgeColor);
|
|
delete[] psar;
|
return ret;
|
}
|
|
/// <summary>
|
/// Add a comparison line to the main price chart.
|
/// </summary>
|
/// <param name="data">The data series to compare to</param>
|
/// <param name="color">The color of the comparison line</param>
|
/// <param name="name">The name of the comparison line</param>
|
/// <returns>The LineLayer object representing the line layer created.</returns>
|
public: LineLayer* addComparison(DoubleArray data, int color, const char *name)
|
{
|
int firstIndex = m_extraPoints;
|
while ((firstIndex < data.len) && (firstIndex < m_closeData.len)) {
|
if ((data[firstIndex] != Chart::NoValue) && (m_closeData[firstIndex] != Chart::NoValue
|
) && (data[firstIndex] != 0) && (m_closeData[firstIndex] != 0)) {
|
break;
|
}
|
firstIndex = firstIndex + 1;
|
}
|
if ((firstIndex >= data.len) || (firstIndex >= m_closeData.len)) {
|
return 0;
|
}
|
|
double scaleFactor = m_closeData[firstIndex] / data[firstIndex];
|
LineLayer* layer = m_mainChart->addLineLayer(ArrayMath(data).mul(scaleFactor).result(
|
), Chart::Transparent);
|
layer->setHTMLImageMap("{disable}");
|
|
Axis* a = m_mainChart->addAxis(Chart::Right, 0);
|
a->setColors(Chart::Transparent, Chart::Transparent);
|
a->syncAxis(m_mainChart->yAxis(), 1 / scaleFactor, 0);
|
|
LineLayer* ret = addLineIndicator2(m_mainChart, data, color, name);
|
ret->setUseYAxis(a);
|
return ret;
|
}
|
|
/// <summary>
|
/// Display percentage axis scale
|
/// </summary>
|
/// <returns>The Axis object representing the percentage axis.</returns>
|
public: Axis* setPercentageAxis()
|
{
|
double firstClose = firstCloseValue();
|
if (firstClose == Chart::NoValue) {
|
return 0;
|
}
|
|
int axisAlign = Chart::Left;
|
if (m_axisOnRight) {
|
axisAlign = Chart::Right;
|
}
|
|
Axis* ret = m_mainChart->addAxis(axisAlign, 0);
|
configureYAxis(ret, 300);
|
ret->syncAxis(m_mainChart->yAxis(), 100 / firstClose);
|
ret->setRounding(false, false);
|
ret->setLabelFormat("{={value}-100|@}%");
|
m_mainChart->yAxis()->setColors(Chart::Transparent, Chart::Transparent);
|
m_mainChart->getPlotArea()->setGridAxis(0, ret);
|
return ret;
|
}
|
|
/// <summary>
|
/// Add a generic band to the main finance chart. This method is used internally by other methods to add
|
/// various bands (eg. Bollinger band, Donchian channels, etc).
|
/// </summary>
|
/// <param name="upperLine">The data series for the upper band line.</param>
|
/// <param name="lowerLine">The data series for the lower band line.</param>
|
/// <param name="lineColor">The color of the upper and lower band line.</param>
|
/// <param name="fillColor">The color to fill the region between the upper and lower band lines.</param>
|
/// <param name="name">The name of the band.</param>
|
/// <returns>An InterLineLayer object representing the filled region.</returns>
|
public: InterLineLayer* addBand(DoubleArray upperLine, DoubleArray lowerLine, int lineColor,
|
int fillColor, const char* name)
|
{
|
int i = upperLine.len - 1;
|
if (i >= lowerLine.len) {
|
i = lowerLine.len - 1;
|
}
|
|
char buffer[1024];
|
while (i >= 0) {
|
if ((upperLine[i] != Chart::NoValue) && (lowerLine[i] != Chart::NoValue)) {
|
sprintf(buffer, "%s: %s - ", name, formatValue(lowerLine[i], m_generalFormat.c_str()));
|
name = strcat(buffer, formatValue(upperLine[i], m_generalFormat.c_str()));
|
break;
|
}
|
i = i - 1;
|
}
|
|
LineLayer *layer = m_mainChart->addLineLayer();
|
layer->addDataSet(upperLine, lineColor, name);
|
layer->addDataSet(lowerLine, lineColor);
|
return m_mainChart->addInterLineLayer(layer->getLine(0), layer->getLine(1), fillColor);
|
}
|
|
/// <summary>
|
/// Add a Bollinger band on the main chart.
|
/// </summary>
|
/// <param name="period">The period to compute the band.</param>
|
/// <param name="bandWidth">The half-width of the band in terms multiples of standard deviation. Typically 2 is used.</param>
|
/// <param name="lineColor">The color of the lines defining the upper and lower limits.</param>
|
/// <param name="fillColor">The color to fill the regional within the band.</param>
|
/// <returns>The InterLineLayer object representing the band created.</returns>
|
public: InterLineLayer* addBollingerBand(int period, double bandWidth, int lineColor,
|
int fillColor)
|
{
|
//Bollinger Band is moving avg +/- (width * moving std deviation)
|
ArrayMath stdDev = ArrayMath(m_closeData).movStdDev(period).mul(bandWidth);
|
ArrayMath movAvg = ArrayMath(m_closeData).movAvg(period);
|
char buffer[1024];
|
sprintf(buffer, "Bollinger (%d, %g)", period, bandWidth);
|
return addBand(ArrayMath(movAvg).add(stdDev), ArrayMath(movAvg).sub(stdDev).selectGTZ(), lineColor,
|
fillColor, buffer);
|
}
|
|
/// <summary>
|
/// Add a Donchian channel on the main chart.
|
/// </summary>
|
/// <param name="period">The period to compute the band.</param>
|
/// <param name="lineColor">The color of the lines defining the upper and lower limits.</param>
|
/// <param name="fillColor">The color to fill the regional within the band.</param>
|
/// <returns>The InterLineLayer object representing the band created.</returns>
|
public: InterLineLayer* addDonchianChannel(int period, int lineColor, int fillColor)
|
{
|
//Donchian Channel is the zone between the moving max and moving min
|
char buffer[1024];
|
sprintf(buffer, "Donchian (%d)", period);
|
return addBand(ArrayMath(m_highData).movMax(period), ArrayMath(m_lowData).movMin(period),
|
lineColor, fillColor, buffer);
|
}
|
|
/// <summary>
|
/// Add a price envelop on the main chart. The price envelop is a defined as a ratio around a
|
/// moving average. For example, a ratio of 0.2 means 20% above and below the moving average.
|
/// </summary>
|
/// <param name="period">The period for the moving average.</param>
|
/// <param name="range">The ratio above and below the moving average.</param>
|
/// <param name="lineColor">The color of the lines defining the upper and lower limits.</param>
|
/// <param name="fillColor">The color to fill the regional within the band.</param>
|
/// <returns>The InterLineLayer object representing the band created.</returns>
|
public: InterLineLayer* addEnvelop(int period, double range, int lineColor, int fillColor)
|
{
|
//Envelop is moving avg +/- percentage
|
ArrayMath movAvg = ArrayMath(m_closeData).movAvg(period);
|
char buffer[1024];
|
sprintf(buffer, "Envelop (SMA %d +/- %g%%)", period, range * 100);
|
return addBand(ArrayMath(movAvg).mul(1 + range), ArrayMath(movAvg).mul(1 - range),
|
lineColor, fillColor, buffer);
|
}
|
|
/// <summary>
|
/// Add a volume bar chart layer on the main chart.
|
/// </summary>
|
/// <param name="height">The height of the bar chart layer in pixels.</param>
|
/// <param name="upColor">The color to used on an 'up' day. An 'up' day is a day where
|
/// the closing price is higher than that of the previous day.</param>
|
/// <param name="downColor">The color to used on a 'down' day. A 'down' day is a day
|
/// where the closing price is lower than that of the previous day.</param>
|
/// <param name="flatColor">The color to used on a 'flat' day. A 'flat' day is a day
|
/// where the closing price is the same as that of the previous day.</param>
|
/// <returns>The XYChart object representing the chart created.</returns>
|
public: BarLayer* addVolBars(int height, int upColor, int downColor, int flatColor)
|
{
|
return addVolBars2(m_mainChart, height, upColor, downColor, flatColor);
|
}
|
|
private: BarLayer* addVolBars2(XYChart* c, int height, int upColor, int downColor, int flatColor)
|
{
|
BarLayer *barLayer = c->addBarLayer(Chart::Overlay);
|
barLayer->setBorderColor(Chart::Transparent);
|
|
if (c == m_mainChart) {
|
configureYAxis(c->yAxis2(), height);
|
int topMargin = c->getDrawArea()->getHeight() - m_topMargin - m_bottomMargin - height +
|
m_yAxisMargin;
|
if (topMargin < 0) {
|
topMargin = 0;
|
}
|
c->yAxis2()->setTopMargin(topMargin);
|
barLayer->setUseYAxis2();
|
}
|
|
Axis *a = c->yAxis2();
|
if (c != m_mainChart) {
|
a = c->yAxis();
|
}
|
|
char buffer[1024];
|
if (ArrayMath(m_volData).maxValue() < 10)
|
sprintf(buffer, "{value|1}%s", m_volUnit.c_str());
|
else
|
sprintf(buffer, "{value}%s", m_volUnit.c_str());
|
a->setLabelFormat(buffer);
|
|
ArrayMath closeChange = ArrayMath(m_closeData).delta().replace(Chart::NoValue, 0);
|
DoubleArray closeChangeData = closeChange.result();
|
|
int i = lastIndex(m_volData);
|
std::string label = "Vol";
|
if (i >= 0) {
|
sprintf(buffer, "%s: %s%s", label.c_str(), formatValue(m_volData[i], m_generalFormat.c_str()),
|
m_volUnit.c_str());
|
label = buffer;
|
}
|
|
DataSet* upDS = barLayer->addDataSet(ArrayMath(m_volData).selectGTZ(closeChange).result(), upColor);
|
DataSet* dnDS = barLayer->addDataSet(ArrayMath(m_volData).selectLTZ(closeChange).result(), downColor);
|
DataSet* flatDS = barLayer->addDataSet(ArrayMath(m_volData).selectEQZ(closeChange).result(), flatColor);
|
|
if ((i < 0) || (closeChangeData[i] == 0) || (closeChangeData[i] == Chart::NoValue)) {
|
flatDS->setDataName(label.c_str());
|
} else if (closeChangeData[i] > 0) {
|
upDS->setDataName(label.c_str());
|
} else {
|
dnDS->setDataName(label.c_str());
|
}
|
|
return barLayer;
|
}
|
|
/// <summary>
|
/// Add a blank indicator chart to the finance chart. Used internally to add other indicators.
|
/// Override to change the default formatting (eg. axis fonts, etc.) of the various indicators.
|
/// </summary>
|
/// <param name="height">The height of the chart in pixels.</param>
|
/// <returns>The XYChart object representing the chart created.</returns>
|
public: XYChart* addIndicator(int height)
|
{
|
//create a new chart object
|
XYChart *ret = new XYChart(m_totalWidth, height + m_topMargin + m_bottomMargin,
|
Chart::Transparent);
|
garbage.push_back(ret);
|
|
ret->setTrimData(m_extraPoints);
|
|
if (m_currentChart != 0) {
|
//if there is a chart before the newly created chart, disable its x-axis, and copy
|
//its x-axis labels to the new chart
|
m_currentChart->xAxis()->setColors(Chart::Transparent, Chart::Transparent);
|
ret->xAxis()->copyAxis(m_currentChart->xAxis());
|
|
//add chart to MultiChart and update the total height
|
addChart(0, m_totalHeight + m_plotAreaGap, ret);
|
m_totalHeight += height + 1 + m_plotAreaGap;
|
} else {
|
//no existing chart - create the x-axis labels from scratch
|
setXLabels(ret->xAxis());
|
|
//add chart to MultiChart and update the total height
|
addChart(0, m_totalHeight, ret);
|
m_totalHeight += height + 1;
|
}
|
|
//the newly created chart becomes the current chart
|
m_currentChart = ret;
|
|
//update the size
|
setSize(m_totalWidth, m_totalHeight + m_topMargin + m_bottomMargin);
|
|
//configure the plot area
|
ret->setPlotArea(m_leftMargin, m_topMargin, m_totalWidth - m_leftMargin - m_rightMargin,
|
height, m_plotAreaBgColor, -1, m_plotAreaBorder)->setGridColor(m_majorHGridColor,
|
m_majorVGridColor, m_minorHGridColor, m_minorVGridColor);
|
ret->setAntiAlias(m_antiAlias);
|
|
//configure legend box
|
if (m_legendFontColor != (int)Chart::Transparent) {
|
LegendBox *box = ret->addLegend(m_leftMargin, m_topMargin, false, m_legendFont.c_str(),
|
m_legendFontSize);
|
box->setFontColor(m_legendFontColor);
|
box->setBackground(m_legendBgColor);
|
box->setMargin(5, 0, 2, 1);
|
box->setSize(m_totalWidth - m_leftMargin - m_rightMargin + 1, 0);
|
}
|
|
//configure x-axis
|
Axis *a = ret->xAxis();
|
a->setIndent(true);
|
a->setTickLength(2, 0);
|
a->setColors(Chart::Transparent, m_xAxisFontColor, m_xAxisFontColor, m_xAxisFontColor);
|
a->setLabelStyle(m_xAxisFont.c_str(), m_xAxisFontSize, m_xAxisFontColor, m_xAxisFontAngle);
|
|
//configure y-axis
|
ret->setYAxisOnRight(m_axisOnRight);
|
configureYAxis(ret->yAxis(), height);
|
|
return ret;
|
}
|
|
private: void configureYAxis(Axis* a, int height)
|
{
|
a->setAutoScale(0, 0.05, 0);
|
if (height < 100) {
|
a->setTickDensity(15);
|
}
|
a->setMargin(m_yAxisMargin);
|
a->setLabelStyle(m_yAxisFont.c_str(), m_yAxisFontSize, m_yAxisFontColor, 0);
|
a->setTickLength(-4, -2);
|
a->setColors(Chart::Transparent, m_yAxisFontColor, m_yAxisFontColor, m_yAxisFontColor);
|
}
|
|
/// <summary>
|
/// Add a generic line indicator chart.
|
/// </summary>
|
/// <param name="height">The height of the indicator chart in pixels.</param>
|
/// <param name="data">The data series of the indicator line.</param>
|
/// <param name="color">The color of the indicator line.</param>
|
/// <param name="name">The name of the indicator.</param>
|
/// <returns>The XYChart object representing the chart created.</returns>
|
public: XYChart* addLineIndicator(int height, DoubleArray data, int color, const char* name)
|
{
|
XYChart *c = addIndicator(height);
|
addLineIndicator2(c, data, color, name);
|
return c;
|
}
|
|
/// <summary>
|
/// Add a line to an existing indicator chart.
|
/// </summary>
|
/// <param name="c">The indicator chart to add the line to.</param>
|
/// <param name="data">The data series of the indicator line.</param>
|
/// <param name="color">The color of the indicator line.</param>
|
/// <param name="name">The name of the indicator.</param>
|
/// <returns>The LineLayer object representing the line created.</returns>
|
public: LineLayer* addLineIndicator2(XYChart* c, DoubleArray data, int color, const char* name)
|
{
|
return c->addLineLayer(data, color, formatIndicatorLabel(name, data).c_str());
|
}
|
|
/// <summary>
|
/// Add a generic bar indicator chart.
|
/// </summary>
|
/// <param name="height">The height of the indicator chart in pixels.</param>
|
/// <param name="data">The data series of the indicator bars.</param>
|
/// <param name="color">The color of the indicator bars.</param>
|
/// <param name="name">The name of the indicator.</param>
|
/// <returns>The XYChart object representing the chart created.</returns>
|
public: XYChart* addBarIndicator(int height, DoubleArray data, int color, const char* name)
|
{
|
XYChart *c = addIndicator(height);
|
addBarIndicator2(c, data, color, name);
|
return c;
|
}
|
|
/// <summary>
|
/// Add a bar layer to an existing indicator chart.
|
/// </summary>
|
/// <param name="c">The indicator chart to add the bar layer to.</param>
|
/// <param name="data">The data series of the indicator bars.</param>
|
/// <param name="color">The color of the indicator bars.</param>
|
/// <param name="name">The name of the indicator.</param>
|
/// <returns>The BarLayer object representing the bar layer created.</returns>
|
public: BarLayer* addBarIndicator2(XYChart* c, DoubleArray data, int color, const char* name)
|
{
|
BarLayer *layer = c->addBarLayer(data, color, formatIndicatorLabel(name, data).c_str());
|
layer->setBorderColor(Chart::Transparent);
|
return layer;
|
}
|
|
/// <summary>
|
/// Add an upper/lower threshold range to an existing indicator chart.
|
/// </summary>
|
/// <param name="c">The indicator chart to add the threshold range to.</param>
|
/// <param name="layer">The line layer that the threshold range applies to.</param>
|
/// <param name="topRange">The upper threshold.</param>
|
/// <param name="topColor">The color to fill the region of the line that is above the
|
/// upper threshold.</param>
|
/// <param name="bottomRange">The lower threshold.</param>
|
/// <param name="bottomColor">The color to fill the region of the line that is below
|
/// the lower threshold.</param>
|
public: void addThreshold(XYChart* c, LineLayer* layer, double topRange, int topColor,
|
double bottomRange, int bottomColor)
|
{
|
Mark *topMark = c->yAxis()->addMark(topRange, topColor, formatValue(topRange,
|
m_generalFormat.c_str()));
|
Mark *bottomMark = c->yAxis()->addMark(bottomRange, bottomColor, formatValue(bottomRange,
|
m_generalFormat.c_str()));
|
|
c->addInterLineLayer(layer->getLine(), topMark->getLine(), topColor, Chart::Transparent);
|
c->addInterLineLayer(layer->getLine(), bottomMark->getLine(), Chart::Transparent,
|
bottomColor);
|
}
|
|
private: std::string formatIndicatorLabel(const char* name, DoubleArray data)
|
{
|
int i = lastIndex(data);
|
if (name == 0) {
|
return name;
|
}
|
char buffer[1024];
|
if ((*name == 0) || (i < 0))
|
//still need sprintf to escape the "%" character
|
sprintf(buffer, "%s", name);
|
else
|
sprintf(buffer, "%s: %s", name, formatValue(data[i], m_generalFormat.c_str()));
|
return buffer;
|
}
|
|
/// <summary>
|
/// Add an Accumulation/Distribution indicator chart.
|
/// </summary>
|
/// <param name="height">The height of the indicator chart in pixels.</param>
|
/// <param name="color">The color of the indicator line.</param>
|
/// <returns>The XYChart object representing the chart created.</returns>
|
public: XYChart* addAccDist(int height, int color)
|
{
|
//Close Location Value = ((C - L) - (H - C)) / (H - L)
|
//Accumulation Distribution Line = Accumulation of CLV * volume
|
ArrayMath range = ArrayMath(m_highData).sub(m_lowData);
|
return addLineIndicator(height, ArrayMath(m_closeData).mul(2).sub(m_lowData).sub(m_highData
|
).mul(m_volData).financeDiv(range, 0).acc(), color, "Accumulation/Distribution");
|
}
|
|
private: ArrayMath computeAroonUp(int period)
|
{
|
double *aroonUp = new double[m_highData.len];
|
|
for(int i = 0; i < m_highData.len; ++i) {
|
double highValue = m_highData[i];
|
if (highValue == Chart::NoValue) {
|
aroonUp[i] = Chart::NoValue;
|
} else {
|
int currentIndex = i;
|
int highCount = period;
|
int count = period;
|
|
while ((count > 0) && (currentIndex >= count)) {
|
currentIndex = currentIndex - 1;
|
double currentValue = m_highData[currentIndex];
|
if (currentValue != Chart::NoValue) {
|
count = count - 1;
|
if (currentValue > highValue) {
|
highValue = currentValue;
|
highCount = count;
|
}
|
}
|
}
|
|
if (count > 0) {
|
aroonUp[i] = Chart::NoValue;
|
} else {
|
aroonUp[i] = highCount * 100.0 / period;
|
}
|
}
|
}
|
|
ArrayMath ret(DoubleArray(aroonUp, m_highData.len));
|
delete[] aroonUp;
|
return ret;
|
}
|
|
private: ArrayMath computeAroonDn(int period)
|
{
|
double *aroonDn = new double[m_lowData.len];
|
|
for(int i = 0; i < m_lowData.len; ++i) {
|
double lowValue = m_lowData[i];
|
if (lowValue == Chart::NoValue) {
|
aroonDn[i] = Chart::NoValue;
|
} else {
|
int currentIndex = i;
|
int lowCount = period;
|
int count = period;
|
|
while ((count > 0) && (currentIndex >= count)) {
|
currentIndex = currentIndex - 1;
|
double currentValue = m_lowData[currentIndex];
|
if (currentValue != Chart::NoValue) {
|
count = count - 1;
|
if (currentValue < lowValue) {
|
lowValue = currentValue;
|
lowCount = count;
|
}
|
}
|
}
|
|
if (count > 0) {
|
aroonDn[i] = Chart::NoValue;
|
} else {
|
aroonDn[i] = lowCount * 100.0 / period;
|
}
|
}
|
}
|
|
ArrayMath ret(DoubleArray(aroonDn, m_lowData.len));
|
delete[] aroonDn;
|
return ret;
|
}
|
|
/// <summary>
|
/// Add an Aroon Up/Down indicators chart.
|
/// </summary>
|
/// <param name="height">The height of the indicator chart in pixels.</param>
|
/// <param name="period">The period to compute the indicators.</param>
|
/// <param name="upColor">The color of the Aroon Up indicator line.</param>
|
/// <param name="downColor">The color of the Aroon Down indicator line.</param>
|
/// <returns>The XYChart object representing the chart created.</returns>
|
public: XYChart* addAroon(int height, int period, int upColor, int downColor)
|
{
|
XYChart *c = addIndicator(height);
|
addLineIndicator2(c, computeAroonUp(period), upColor, "Aroon Up");
|
addLineIndicator2(c, computeAroonDn(period), downColor, "Aroon Down");
|
c->yAxis()->setLinearScale(0, 100);
|
return c;
|
}
|
|
/// <summary>
|
/// Add an Aroon Oscillator indicator chart.
|
/// </summary>
|
/// <param name="height">The height of the indicator chart in pixels.</param>
|
/// <param name="period">The period to compute the indicator.</param>
|
/// <param name="color">The color of the indicator line.</param>
|
/// <returns>The XYChart object representing the chart created.</returns>
|
public: XYChart* addAroonOsc(int height, int period, int color)
|
{
|
char buffer[1024];
|
sprintf(buffer, "Aroon Oscillator (%d)", period);
|
XYChart *c = addLineIndicator(height, computeAroonUp(period).sub(computeAroonDn(
|
period)), color, buffer);
|
c->yAxis()->setLinearScale(-100, 100);
|
return c;
|
}
|
|
private: ArrayMath computeTrueRange()
|
{
|
ArrayMath previousClose = ArrayMath(m_closeData).shift();
|
DoubleArray previousCloseData = previousClose.result();
|
ArrayMath range = ArrayMath(m_highData).sub(m_lowData);
|
DoubleArray rangeData = range.result();
|
double temp = 0;
|
|
double *ret = new double[m_highData.len];
|
for(int i = 0; i < m_highData.len; ++i) {
|
ret[i] = rangeData[i];
|
if ((ret[i] != Chart::NoValue) && (previousCloseData[i] != Chart::NoValue)) {
|
temp = fabs(m_highData[i] - previousCloseData[i]);
|
if (temp > ret[i]) {
|
ret[i] = temp;
|
}
|
temp = fabs(previousCloseData[i] - m_lowData[i]);
|
if (temp > ret[i]) {
|
ret[i] = temp;
|
}
|
}
|
}
|
|
ArrayMath ret1(DoubleArray(ret, m_highData.len));
|
delete[] ret;
|
return ret1;
|
}
|
|
/// <summary>
|
/// Add an Average Directional Index indicators chart.
|
/// </summary>
|
/// <param name="height">The height of the indicator chart in pixels.</param>
|
/// <param name="period">The period to compute the indicator.</param>
|
/// <param name="posColor">The color of the Positive Directional Index line.</param>
|
/// <param name="negColor">The color of the Negatuve Directional Index line.</param>
|
/// <param name="color">The color of the Average Directional Index line.</param>
|
/// <returns>The XYChart object representing the chart created.</returns>
|
public: XYChart* addADX(int height, int period, int posColor, int negColor, int color)
|
{
|
//pos/neg directional movement
|
ArrayMath pos = ArrayMath(m_highData).delta().selectGTZ();
|
ArrayMath neg = ArrayMath(m_lowData).delta().mul(-1).selectGTZ();
|
ArrayMath delta = ArrayMath(pos).sub(neg);
|
pos.selectGTZ(delta);
|
neg.selectLTZ(delta);
|
|
//initial value
|
DoubleArray posData = pos.result();
|
DoubleArray negData = neg.result();
|
if ((posData.len > 1) && (posData[1] != Chart::NoValue) && (negData[1] !=
|
Chart::NoValue)) {
|
const_cast<double *>(posData.data)[1] = (posData[1] * 2 + negData[1]) / 3;
|
const_cast<double *>(negData.data)[1] = (negData[1] + posData[1]) / 2;
|
pos = ArrayMath(posData);
|
neg = ArrayMath(negData);
|
}
|
|
//pos/neg directional index
|
ArrayMath tr = computeTrueRange();
|
tr.expAvg(1.0 / period);
|
pos.expAvg(1.0 / period).financeDiv(tr, 0).mul(100);
|
neg.expAvg(1.0 / period).financeDiv(tr, 0).mul(100);
|
|
//directional movement index ??? what happen if division by zero???
|
ArrayMath totalDM = ArrayMath(pos).add(neg);
|
ArrayMath dx = ArrayMath(pos).sub(neg).abs().financeDiv(totalDM,
|
0).mul(100).expAvg(1.0 / period);
|
|
XYChart *c = addIndicator(height);
|
char buffer1[1024];
|
sprintf(buffer1, "+DI (%d)", period);
|
char buffer2[1024];
|
sprintf(buffer2, "-DI (%d)", period);
|
char buffer3[1024];
|
sprintf(buffer3, "ADX (%d)", period);
|
addLineIndicator2(c, pos, posColor, buffer1);
|
addLineIndicator2(c, neg, negColor, buffer2);
|
addLineIndicator2(c, dx, color, buffer3);
|
return c;
|
}
|
|
/// <summary>
|
/// Add an Average True Range indicators chart.
|
/// </summary>
|
/// <param name="height">The height of the indicator chart in pixels.</param>
|
/// <param name="period">The period to compute the indicator.</param>
|
/// <param name="color1">The color of the True Range line.</param>
|
/// <param name="color2">The color of the Average True Range line.</param>
|
/// <returns>The XYChart object representing the chart created.</returns>
|
public: XYChart* addATR(int height, int period, int color1, int color2)
|
{
|
ArrayMath trueRange = computeTrueRange();
|
XYChart *c = addLineIndicator(height, trueRange, color1, "True Range");
|
char buffer[1024];
|
sprintf(buffer, "Average True Range (%d)", period);
|
addLineIndicator2(c, ArrayMath(trueRange).expAvg(2.0 / (period + 1)), color2, buffer);
|
return c;
|
}
|
|
/// <summary>
|
/// Add a Bollinger Band Width indicator chart.
|
/// </summary>
|
/// <param name="height">The height of the indicator chart in pixels.</param>
|
/// <param name="period">The period to compute the indicator.</param>
|
/// <param name="width">The band width to compute the indicator.</param>
|
/// <param name="color">The color of the indicator line.</param>
|
/// <returns>The XYChart object representing the chart created.</returns>
|
public: XYChart* addBollingerWidth(int height, int period, double width, int color)
|
{
|
char buffer[1024];
|
sprintf(buffer, "Bollinger Width (%d, %g)", period, width);
|
return addLineIndicator(height, ArrayMath(m_closeData).movStdDev(period).mul(width * 2), color,
|
buffer);
|
}
|
|
/// <summary>
|
/// Add a Community Channel Index indicator chart.
|
/// </summary>
|
/// <param name="height">The height of the indicator chart in pixels.</param>
|
/// <param name="period">The period to compute the indicator.</param>
|
/// <param name="color">The color of the indicator line.</param>
|
/// <param name="deviation">The distance beween the middle line and the upper and lower threshold lines.</param>
|
/// <param name="upColor">The fill color when the indicator exceeds the upper threshold line.</param>
|
/// <param name="downColor">The fill color when the indicator falls below the lower threshold line.</param>
|
/// <returns>The XYChart object representing the chart created.</returns>
|
public: XYChart* addCCI(int height, int period, int color, double deviation, int upColor,
|
int downColor)
|
{
|
//typical price
|
ArrayMath tp = ArrayMath(m_highData).add(m_lowData).add(m_closeData).div(3);
|
DoubleArray tpData = tp.result();
|
|
//simple moving average of typical price
|
ArrayMath smvtp = ArrayMath(tp).movAvg(period);
|
DoubleArray smvtpData = smvtp.result();
|
|
//compute mean deviation
|
double *movMeanDev = new double[smvtpData.len];
|
|
for(int i = 0; i < smvtpData.len; ++i) {
|
double avg = smvtpData[i];
|
if (avg == Chart::NoValue) {
|
movMeanDev[i] = Chart::NoValue;
|
} else {
|
int currentIndex = i;
|
int count = period - 1;
|
double acc = 0;
|
|
while ((count >= 0) && (currentIndex >= count)) {
|
double currentValue = tpData[currentIndex];
|
currentIndex = currentIndex - 1;
|
if (currentValue != Chart::NoValue) {
|
count = count - 1;
|
acc = acc + fabs(avg - currentValue);
|
}
|
}
|
|
if (count > 0) {
|
movMeanDev[i] = Chart::NoValue;
|
} else {
|
movMeanDev[i] = acc / period;
|
}
|
}
|
}
|
|
XYChart *c = addIndicator(height);
|
char buffer[1024];
|
sprintf(buffer, "CCI (%d)", period);
|
LineLayer *layer = addLineIndicator2(c, ArrayMath(tp).sub(smvtpData).financeDiv(
|
DoubleArray(movMeanDev, smvtpData.len), 0).div(0.015), color, buffer);
|
addThreshold(c, layer, deviation, upColor, -deviation, downColor);
|
|
delete[] movMeanDev;
|
return c;
|
}
|
|
/// <summary>
|
/// Add a Chaikin Money Flow indicator chart.
|
/// </summary>
|
/// <param name="height">The height of the indicator chart in pixels.</param>
|
/// <param name="period">The period to compute the indicator.</param>
|
/// <param name="color">The color of the indicator line.</param>
|
/// <returns>The XYChart object representing the chart created.</returns>
|
public: XYChart* addChaikinMoneyFlow(int height, int period, int color)
|
{
|
ArrayMath range = ArrayMath(m_highData).sub(m_lowData);
|
ArrayMath volAvg = ArrayMath(m_volData).movAvg(period);
|
char buffer[1024];
|
sprintf(buffer, "Chaikin Money Flow (%d)", period);
|
return addBarIndicator(height, ArrayMath(m_closeData).mul(2).sub(m_lowData).sub(m_highData
|
).mul(m_volData).financeDiv(range, 0).movAvg(period).financeDiv(volAvg, 0), color, buffer
|
);
|
}
|
|
/// <summary>
|
/// Add a Chaikin Oscillator indicator chart.
|
/// </summary>
|
/// <param name="height">The height of the indicator chart in pixels.</param>
|
/// <param name="color">The color of the indicator line.</param>
|
/// <returns>The XYChart object representing the chart created.</returns>
|
public: XYChart* addChaikinOscillator(int height, int color)
|
{
|
//first compute acc/dist line
|
ArrayMath range = ArrayMath(m_highData).sub(m_lowData);
|
ArrayMath accdist = ArrayMath(m_closeData).mul(2).sub(m_lowData).sub(m_highData).mul(
|
m_volData).financeDiv(range, 0).acc();
|
|
//chaikin osc = exp3(accdist) - exp10(accdist)
|
ArrayMath expAvg10 = ArrayMath(accdist).expAvg(2.0 / (10 + 1));
|
return addLineIndicator(height, ArrayMath(accdist).expAvg(2.0 / (3 + 1)).sub(expAvg10), color,
|
"Chaikin Oscillator");
|
}
|
|
/// <summary>
|
/// Add a Chaikin Volatility indicator chart.
|
/// </summary>
|
/// <param name="height">The height of the indicator chart in pixels.</param>
|
/// <param name="period1">The period to smooth the range.</param>
|
/// <param name="period2">The period to compute the rate of change of the smoothed range.</param>
|
/// <param name="color">The color of the indicator line.</param>
|
/// <returns>The XYChart object representing the chart created.</returns>
|
public: XYChart* addChaikinVolatility(int height, int period1, int period2, int color)
|
{
|
char buffer[1024];
|
sprintf(buffer, "Chaikin Volatility (%d, %d)", period1, period2);
|
return addLineIndicator(height, ArrayMath(m_highData).sub(m_lowData).expAvg(2.0 / (period1 +
|
1)).rate(period2).sub(1).mul(100), color, buffer);
|
}
|
|
/// <summary>
|
/// Add a Close Location Value indicator chart.
|
/// </summary>
|
/// <param name="height">The height of the indicator chart in pixels.</param>
|
/// <param name="color">The color of the indicator line.</param>
|
/// <returns>The XYChart object representing the chart created.</returns>
|
public: XYChart* addCLV(int height, int color)
|
{
|
//Close Location Value = ((C - L) - (H - C)) / (H - L)
|
ArrayMath range = ArrayMath(m_highData).sub(m_lowData);
|
return addLineIndicator(height, ArrayMath(m_closeData).mul(2).sub(m_lowData).sub(m_highData
|
).financeDiv(range, 0), color, "Close Location Value");
|
}
|
|
/// <summary>
|
/// Add a Detrended Price Oscillator indicator chart.
|
/// </summary>
|
/// <param name="height">The height of the indicator chart in pixels.</param>
|
/// <param name="period">The period to compute the indicator.</param>
|
/// <param name="color">The color of the indicator line.</param>
|
/// <returns>The XYChart object representing the chart created.</returns>
|
public: XYChart* addDPO(int height, int period, int color)
|
{
|
char buffer[1024];
|
sprintf(buffer, "DPO (%d)", period);
|
return addLineIndicator(height, ArrayMath(m_closeData).movAvg(period).shift(period / 2 + 1
|
).sub(m_closeData).mul(-1), color, buffer);
|
}
|
|
/// <summary>
|
/// Add a Donchian Channel Width indicator chart.
|
/// </summary>
|
/// <param name="height">The height of the indicator chart in pixels.</param>
|
/// <param name="period">The period to compute the indicator.</param>
|
/// <param name="color">The color of the indicator line.</param>
|
/// <returns>The XYChart object representing the chart created.</returns>
|
public: XYChart* addDonchianWidth(int height, int period, int color)
|
{
|
char buffer[1024];
|
sprintf(buffer, "Donchian Width (%d)", period);
|
return addLineIndicator(height, ArrayMath(m_highData).movMax(period).sub(ArrayMath(m_lowData
|
).movMin(period)), color, buffer);
|
}
|
|
/// <summary>
|
/// Add a Ease of Movement indicator chart.
|
/// </summary>
|
/// <param name="height">The height of the indicator chart in pixels.</param>
|
/// <param name="period">The period to smooth the indicator.</param>
|
/// <param name="color1">The color of the indicator line.</param>
|
/// <param name="color2">The color of the smoothed indicator line.</param>
|
/// <returns>The XYChart object representing the chart created.</returns>
|
public: XYChart* addEaseOfMovement(int height, int period, int color1, int color2)
|
{
|
ArrayMath boxRatioInverted = ArrayMath(m_highData).sub(m_lowData).financeDiv(m_volData, 0);
|
ArrayMath result = ArrayMath(m_highData).add(m_lowData).div(2).delta().mul(boxRatioInverted)
|
;
|
|
XYChart *c = addLineIndicator(height, result, color1, "EMV");
|
char buffer[1024];
|
sprintf(buffer, "EMV EMA (%d)", period);
|
addLineIndicator2(c, ArrayMath(result).movAvg(period), color2, buffer);
|
return c;
|
}
|
|
/// <summary>
|
/// Add a Fast Stochastic indicator chart.
|
/// </summary>
|
/// <param name="height">The height of the indicator chart in pixels.</param>
|
/// <param name="period1">The period to compute the %K line.</param>
|
/// <param name="period2">The period to compute the %D line.</param>
|
/// <param name="color1">The color of the %K line.</param>
|
/// <param name="color2">The color of the %D line.</param>
|
/// <returns>The XYChart object representing the chart created.</returns>
|
public: XYChart* addFastStochastic(int height, int period1, int period2, int color1, int color2)
|
{
|
ArrayMath movLow = ArrayMath(m_lowData).movMin(period1);
|
ArrayMath movRange = ArrayMath(m_highData).movMax(period1).sub(movLow);
|
ArrayMath stochastic = ArrayMath(m_closeData).sub(movLow).financeDiv(movRange, 0.5).mul(100)
|
;
|
|
char buffer[1024];
|
sprintf(buffer, "Fast Stochastic %%K (%d)", period1);
|
XYChart *c = addLineIndicator(height, stochastic, color1, buffer);
|
sprintf(buffer, "%%D (%d)", period2);
|
addLineIndicator2(c, ArrayMath(stochastic).movAvg(period2), color2, buffer);
|
|
c->yAxis()->setLinearScale(0, 100);
|
return c;
|
}
|
|
/// <summary>
|
/// Add a MACD indicator chart.
|
/// </summary>
|
/// <param name="height">The height of the indicator chart in pixels.</param>
|
/// <param name="period1">The first moving average period to compute the indicator.</param>
|
/// <param name="period2">The second moving average period to compute the indicator.</param>
|
/// <param name="period3">The moving average period of the signal line.</param>
|
/// <param name="color">The color of the indicator line.</param>
|
/// <param name="signalColor">The color of the signal line.</param>
|
/// <param name="divColor">The color of the divergent bars.</param>
|
/// <returns>The XYChart object representing the chart created.</returns>
|
public: XYChart* addMACD(int height, int period1, int period2, int period3, int color,
|
int signalColor, int divColor)
|
{
|
XYChart *c = addIndicator(height);
|
char buffer[1024];
|
|
//MACD is defined as the difference between two exponential averages (typically 12/26 days)
|
ArrayMath expAvg1 = ArrayMath(m_closeData).expAvg(2.0 / (period1 + 1));
|
ArrayMath macd = ArrayMath(m_closeData).expAvg(2.0 / (period2 + 1)).sub(expAvg1);
|
|
//Add the MACD line
|
sprintf(buffer, "MACD (%d, %d)", period1, period2);
|
addLineIndicator2(c, macd, color, buffer);
|
|
//MACD signal line
|
ArrayMath macdSignal = ArrayMath(macd).expAvg(2.0 / (period3 + 1));
|
sprintf(buffer, "EXP (%d)", period3);
|
addLineIndicator2(c, macdSignal, signalColor, buffer);
|
|
//Divergence
|
addBarIndicator2(c, ArrayMath(macd).sub(macdSignal), divColor, "Divergence");
|
|
return c;
|
}
|
|
/// <summary>
|
/// Add a Mass Index indicator chart.
|
/// </summary>
|
/// <param name="height">The height of the indicator chart in pixels.</param>
|
/// <param name="color">The color of the indicator line.</param>
|
/// <param name="upColor">The fill color when the indicator exceeds the upper threshold line.</param>
|
/// <param name="downColor">The fill color when the indicator falls below the lower threshold line.</param>
|
/// <returns>The XYChart object representing the chart created.</returns>
|
public: XYChart* addMassIndex(int height, int color, int upColor, int downColor)
|
{
|
//Mass Index
|
double f = 2.0 / (10);
|
ArrayMath exp9 = ArrayMath(m_highData).sub(m_lowData).expAvg(f);
|
ArrayMath exp99 = ArrayMath(exp9).expAvg(f);
|
|
XYChart *c = addLineIndicator(height, ArrayMath(exp9).financeDiv(exp99, 1).movAvg(25).mul(25
|
), color, "Mass Index");
|
c->yAxis()->addMark(27, upColor);
|
c->yAxis()->addMark(26.5, downColor);
|
return c;
|
}
|
|
/// <summary>
|
/// Add a Money Flow Index indicator chart.
|
/// </summary>
|
/// <param name="height">The height of the indicator chart in pixels.</param>
|
/// <param name="period">The period to compute the indicator.</param>
|
/// <param name="color">The color of the indicator line.</param>
|
/// <param name="range">The distance beween the middle line and the upper and lower threshold lines.</param>
|
/// <param name="upColor">The fill color when the indicator exceeds the upper threshold line.</param>
|
/// <param name="downColor">The fill color when the indicator falls below the lower threshold line.</param>
|
/// <returns>The XYChart object representing the chart created.</returns>
|
public: XYChart* addMFI(int height, int period, int color, double range, int upColor,
|
int downColor)
|
{
|
//Money Flow Index
|
ArrayMath typicalPrice = ArrayMath(m_highData).add(m_lowData).add(m_closeData).div(3);
|
ArrayMath moneyFlow = ArrayMath(typicalPrice).mul(m_volData);
|
|
ArrayMath selector = ArrayMath(typicalPrice).delta();
|
ArrayMath posMoneyFlow = ArrayMath(moneyFlow).selectGTZ(selector).movAvg(period);
|
ArrayMath posNegMoneyFlow = ArrayMath(moneyFlow).selectLTZ(selector).movAvg(period).add(
|
posMoneyFlow);
|
|
XYChart *c = addIndicator(height);
|
char buffer[1024];
|
sprintf(buffer, "Money Flow Index (%d)", period);
|
LineLayer *layer = addLineIndicator2(c, ArrayMath(posMoneyFlow).financeDiv(posNegMoneyFlow,
|
0.5).mul(100), color, buffer);
|
addThreshold(c, layer, 50 + range, upColor, 50 - range, downColor);
|
|
c->yAxis()->setLinearScale(0, 100);
|
return c;
|
}
|
|
/// <summary>
|
/// Add a Momentum indicator chart.
|
/// </summary>
|
/// <param name="height">The height of the indicator chart in pixels.</param>
|
/// <param name="period">The period to compute the indicator.</param>
|
/// <param name="color">The color of the indicator line.</param>
|
/// <returns>The XYChart object representing the chart created.</returns>
|
public: XYChart* addMomentum(int height, int period, int color)
|
{
|
char buffer[1024];
|
sprintf(buffer, "Momentum (%d)", period);
|
return addLineIndicator(height, ArrayMath(m_closeData).delta(period), color, buffer);
|
}
|
|
/// <summary>
|
/// Add a Negative Volume Index indicator chart.
|
/// </summary>
|
/// <param name="height">The height of the indicator chart in pixels.</param>
|
/// <param name="period">The period to compute the signal line.</param>
|
/// <param name="color">The color of the indicator line.</param>
|
/// <param name="signalColor">The color of the signal line.</param>
|
/// <returns>The XYChart object representing the chart created.</returns>
|
public: XYChart* addNVI(int height, int period, int color, int signalColor)
|
{
|
double *nvi = new double[m_volData.len];
|
|
double previousNVI = 100;
|
double previousVol = Chart::NoValue;
|
double previousClose = Chart::NoValue;
|
int i;
|
for(i = 0; i < m_volData.len; ++i) {
|
if (m_volData[i] == Chart::NoValue) {
|
nvi[i] = Chart::NoValue;
|
} else {
|
if ((previousVol != Chart::NoValue) && (m_volData[i] < previousVol) && (
|
previousClose != Chart::NoValue) && (m_closeData[i] != Chart::NoValue)) {
|
nvi[i] = previousNVI + previousNVI * (m_closeData[i] - previousClose) /
|
previousClose;
|
} else {
|
nvi[i] = previousNVI;
|
}
|
|
previousNVI = nvi[i];
|
previousVol = m_volData[i];
|
previousClose = m_closeData[i];
|
}
|
}
|
|
XYChart *c = addLineIndicator(height, DoubleArray(nvi, m_volData.len), color, "NVI");
|
if (m_volData.len > period) {
|
char buffer[1024];
|
sprintf(buffer, "NVI SMA (%d)", period);
|
addLineIndicator2(c, ArrayMath(DoubleArray(nvi, m_volData.len)).movAvg(period),
|
signalColor, buffer);
|
}
|
|
delete[] nvi;
|
return c;
|
}
|
|
/// <summary>
|
/// Add an On Balance Volume indicator chart.
|
/// </summary>
|
/// <param name="height">The height of the indicator chart in pixels.</param>
|
/// <param name="color">The color of the indicator line.</param>
|
/// <returns>The XYChart object representing the chart created.</returns>
|
public: XYChart* addOBV(int height, int color)
|
{
|
ArrayMath closeChange = ArrayMath(m_closeData).delta();
|
ArrayMath upVolume = ArrayMath(m_volData).selectGTZ(closeChange);
|
ArrayMath downVolume = ArrayMath(m_volData).selectLTZ(closeChange);
|
|
return addLineIndicator(height, ArrayMath(upVolume).sub(downVolume).acc(), color, "OBV");
|
}
|
|
/// <summary>
|
/// Add a Performance indicator chart.
|
/// </summary>
|
/// <param name="height">The height of the indicator chart in pixels.</param>
|
/// <param name="color">The color of the indicator line.</param>
|
/// <returns>The XYChart object representing the chart created.</returns>
|
public: XYChart* addPerformance(int height, int color)
|
{
|
double closeValue = firstCloseValue();
|
if (closeValue != Chart::NoValue) {
|
return addLineIndicator(height, ArrayMath(m_closeData).mul(100 / closeValue
|
).sub(100).result(), color, "Performance");
|
} else {
|
//chart is empty !!!
|
return addIndicator(height);
|
}
|
}
|
|
/// <summary>
|
/// Add a Percentage Price Oscillator indicator chart.
|
/// </summary>
|
/// <param name="height">The height of the indicator chart in pixels.</param>
|
/// <param name="period1">The first moving average period to compute the indicator.</param>
|
/// <param name="period2">The second moving average period to compute the indicator.</param>
|
/// <param name="period3">The moving average period of the signal line.</param>
|
/// <param name="color">The color of the indicator line.</param>
|
/// <param name="signalColor">The color of the signal line.</param>
|
/// <param name="divColor">The color of the divergent bars.</param>
|
/// <returns>The XYChart object representing the chart created.</returns>
|
public: XYChart* addPPO(int height, int period1, int period2, int period3, int color,
|
int signalColor, int divColor)
|
{
|
ArrayMath expAvg1 = ArrayMath(m_closeData).expAvg(2.0 / (period1 + 1));
|
ArrayMath expAvg2 = ArrayMath(m_closeData).expAvg(2.0 / (period2 + 1));
|
ArrayMath ppo = ArrayMath(expAvg2).sub(expAvg1).financeDiv(expAvg2, 0).mul(100);
|
ArrayMath ppoSignal = ArrayMath(ppo).expAvg(2.0 / (period3 + 1));
|
|
char buffer[1024];
|
sprintf(buffer, "PPO (%d, %d)", period1, period2);
|
XYChart *c = addLineIndicator(height, ppo, color, buffer);
|
sprintf(buffer, "EMA (%d)", period3);
|
addLineIndicator2(c, ppoSignal, signalColor, buffer);
|
addBarIndicator2(c, ppo.sub(ppoSignal), divColor, "Divergence");
|
return c;
|
}
|
|
/// <summary>
|
/// Add a Positive Volume Index indicator chart.
|
/// </summary>
|
/// <param name="height">The height of the indicator chart in pixels.</param>
|
/// <param name="period">The period to compute the signal line.</param>
|
/// <param name="color">The color of the indicator line.</param>
|
/// <param name="signalColor">The color of the signal line.</param>
|
/// <returns>The XYChart object representing the chart created.</returns>
|
public: XYChart* addPVI(int height, int period, int color, int signalColor)
|
{
|
//Positive Volume Index
|
double *pvi = new double[m_volData.len];
|
|
double previousPVI = 100;
|
double previousVol = Chart::NoValue;
|
double previousClose = Chart::NoValue;
|
int i;
|
for(i = 0; i < m_volData.len; ++i) {
|
if (m_volData[i] == Chart::NoValue) {
|
pvi[i] = Chart::NoValue;
|
} else {
|
if ((previousVol != Chart::NoValue) && (m_volData[i] > previousVol) && (
|
previousClose != Chart::NoValue) && (m_closeData[i] != Chart::NoValue)) {
|
pvi[i] = previousPVI + previousPVI * (m_closeData[i] - previousClose) /
|
previousClose;
|
} else {
|
pvi[i] = previousPVI;
|
}
|
|
previousPVI = pvi[i];
|
previousVol = m_volData[i];
|
previousClose = m_closeData[i];
|
}
|
}
|
|
XYChart *c = addLineIndicator(height, DoubleArray(pvi, m_volData.len), color, "PVI");
|
if (m_volData.len > period) {
|
char buffer[1024];
|
sprintf(buffer, "PVI SMA (%d)", period);
|
addLineIndicator2(c, ArrayMath(DoubleArray(pvi, m_volData.len)).movAvg(period),
|
signalColor, buffer);
|
}
|
|
delete[] pvi;
|
return c;
|
}
|
|
/// <summary>
|
/// Add a Percentage Volume Oscillator indicator chart.
|
/// </summary>
|
/// <param name="height">The height of the indicator chart in pixels.</param>
|
/// <param name="period1">The first moving average period to compute the indicator.</param>
|
/// <param name="period2">The second moving average period to compute the indicator.</param>
|
/// <param name="period3">The moving average period of the signal line.</param>
|
/// <param name="color">The color of the indicator line.</param>
|
/// <param name="signalColor">The color of the signal line.</param>
|
/// <param name="divColor">The color of the divergent bars.</param>
|
/// <returns>The XYChart object representing the chart created.</returns>
|
public: XYChart* addPVO(int height, int period1, int period2, int period3, int color,
|
int signalColor, int divColor)
|
{
|
ArrayMath expAvg1 = ArrayMath(m_volData).expAvg(2.0 / (period1 + 1));
|
ArrayMath expAvg2 = ArrayMath(m_volData).expAvg(2.0 / (period2 + 1));
|
ArrayMath pvo = ArrayMath(expAvg2).sub(expAvg1).financeDiv(expAvg2, 0).mul(100);
|
ArrayMath pvoSignal = ArrayMath(pvo).expAvg(2.0 / (period3 + 1));
|
|
char buffer[1024];
|
sprintf(buffer, "PVO (%d, %d)", period1, period2);
|
XYChart *c = addLineIndicator(height, pvo, color, buffer);
|
sprintf(buffer, "EMA (%d)", period3);
|
addLineIndicator2(c, pvoSignal, signalColor, buffer);
|
addBarIndicator2(c, pvo.sub(pvoSignal), divColor, "Divergence");
|
return c;
|
}
|
|
/// <summary>
|
/// Add a Price Volumne Trend indicator chart.
|
/// </summary>
|
/// <param name="height">The height of the indicator chart in pixels.</param>
|
/// <param name="color">The color of the indicator line.</param>
|
/// <returns>The XYChart object representing the chart created.</returns>
|
public: XYChart* addPVT(int height, int color)
|
{
|
return addLineIndicator(height, ArrayMath(m_closeData).rate().sub(1).mul(m_volData).acc(),
|
color, "PVT");
|
}
|
|
/// <summary>
|
/// Add a Rate of Change indicator chart.
|
/// </summary>
|
/// <param name="height">The height of the indicator chart in pixels.</param>
|
/// <param name="period">The period to compute the indicator.</param>
|
/// <param name="color">The color of the indicator line.</param>
|
/// <returns>The XYChart object representing the chart created.</returns>
|
public: XYChart* addROC(int height, int period, int color)
|
{
|
char buffer[1024];
|
sprintf(buffer, "ROC (%d)", period);
|
return addLineIndicator(height, ArrayMath(m_closeData).rate(period).sub(1).mul(100), color,
|
buffer);
|
}
|
|
private: ArrayMath& RSIMovAvg(ArrayMath& dataRef, int period) {
|
//The "moving average" in classical RSI is based on a formula that mixes simple
|
//and exponential moving averages.
|
|
if (period <= 0)
|
period = 1;
|
|
int count = 0;
|
double acc = 0;
|
int dataLen = dataRef.result().len;
|
double *data = const_cast<double *>(dataRef.result().data);
|
|
for (int i = 0; i < dataLen; ++i) {
|
if (fabs(data[i] / Chart::NoValue - 1) > 1e-005) {
|
++count;
|
acc += data[i];
|
if (count < period) {
|
data[i] = Chart::NoValue;
|
} else {
|
data[i] = acc / period;
|
acc = data[i] * (period - 1);
|
}
|
}
|
}
|
|
return dataRef;
|
}
|
|
private: ArrayMath computeRSI(int period)
|
{
|
//RSI is defined as the average up changes for the last 14 days, divided by the
|
//average absolute changes for the last 14 days, expressed as a percentage.
|
|
return RSIMovAvg(ArrayMath(m_closeData).delta().selectGTZ(), period).financeDiv(
|
RSIMovAvg(ArrayMath(m_closeData).delta().abs(), period), 0.5).mul(100);
|
}
|
|
/// <summary>
|
/// Add a Relative Strength Index indicator chart.
|
/// </summary>
|
/// <param name="height">The height of the indicator chart in pixels.</param>
|
/// <param name="period">The period to compute the indicator.</param>
|
/// <param name="color">The color of the indicator line.</param>
|
/// <param name="range">The distance beween the middle line and the upper and lower threshold lines.</param>
|
/// <param name="upColor">The fill color when the indicator exceeds the upper threshold line.</param>
|
/// <param name="downColor">The fill color when the indicator falls below the lower threshold line.</param>
|
/// <returns>The XYChart object representing the chart created.</returns>
|
public: XYChart* addRSI(int height, int period, int color, double range, int upColor,
|
int downColor)
|
{
|
XYChart *c = addIndicator(height);
|
char buffer[1024];
|
sprintf(buffer, "RSI (%d)", period);
|
LineLayer *layer = addLineIndicator2(c, computeRSI(period), color, buffer);
|
|
//Add range if given
|
if ((range > 0) && (range < 50)) {
|
addThreshold(c, layer, 50 + range, upColor, 50 - range, downColor);
|
}
|
c->yAxis()->setLinearScale(0, 100);
|
return c;
|
}
|
|
/// <summary>
|
/// Add a Slow Stochastic indicator chart.
|
/// </summary>
|
/// <param name="height">The height of the indicator chart in pixels.</param>
|
/// <param name="period1">The period to compute the %K line.</param>
|
/// <param name="period2">The period to compute the %D line.</param>
|
/// <param name="color1">The color of the %K line.</param>
|
/// <param name="color2">The color of the %D line.</param>
|
/// <returns>The XYChart object representing the chart created.</returns>
|
public: XYChart* addSlowStochastic(int height, int period1, int period2, int color1, int color2)
|
{
|
ArrayMath movLow = ArrayMath(m_lowData).movMin(period1);
|
ArrayMath movRange = ArrayMath(m_highData).movMax(period1).sub(movLow);
|
ArrayMath stochastic = ArrayMath(m_closeData).sub(movLow).financeDiv(movRange, 0.5
|
).mul(100).movAvg(3);
|
|
char buffer[1024];
|
sprintf(buffer, "Slow Stochastic %%K (%d)", period1);
|
XYChart *c = addLineIndicator(height, stochastic, color1, buffer);
|
sprintf(buffer, "%%D (%d)", period2);
|
addLineIndicator2(c, stochastic.movAvg(period2), color2, buffer);
|
|
c->yAxis()->setLinearScale(0, 100);
|
return c;
|
}
|
|
/// <summary>
|
/// Add a Moving Standard Deviation indicator chart.
|
/// </summary>
|
/// <param name="height">The height of the indicator chart in pixels.</param>
|
/// <param name="period">The period to compute the indicator.</param>
|
/// <param name="color">The color of the indicator line.</param>
|
/// <returns>The XYChart object representing the chart created.</returns>
|
public: XYChart* addStdDev(int height, int period, int color)
|
{
|
char buffer[1024];
|
sprintf(buffer, "Moving StdDev (%d)", period);
|
return addLineIndicator(height, ArrayMath(m_closeData).movStdDev(period), color, buffer);
|
}
|
|
/// <summary>
|
/// Add a Stochastic RSI indicator chart.
|
/// </summary>
|
/// <param name="height">The height of the indicator chart in pixels.</param>
|
/// <param name="period">The period to compute the indicator.</param>
|
/// <param name="color">The color of the indicator line.</param>
|
/// <param name="range">The distance beween the middle line and the upper and lower threshold lines.</param>
|
/// <param name="upColor">The fill color when the indicator exceeds the upper threshold line.</param>
|
/// <param name="downColor">The fill color when the indicator falls below the lower threshold line.</param>
|
/// <returns>The XYChart object representing the chart created.</returns>
|
public: XYChart* addStochRSI(int height, int period, int color, double range, int upColor,
|
int downColor)
|
{
|
ArrayMath rsi = computeRSI(period);
|
ArrayMath movLow = ArrayMath(rsi).movMin(period);
|
ArrayMath movRange = ArrayMath(rsi).movMax(period).sub(movLow);
|
|
XYChart *c = addIndicator(height);
|
char buffer[1024];
|
sprintf(buffer, "StochRSI (%d)", period);
|
LineLayer *layer = addLineIndicator2(c, ArrayMath(rsi).sub(movLow).financeDiv(movRange, 0.5
|
).mul(100), color, buffer);
|
|
//Add range if given
|
if ((range > 0) && (range < 50)) {
|
addThreshold(c, layer, 50 + range, upColor, 50 - range, downColor);
|
}
|
c->yAxis()->setLinearScale(0, 100);
|
return c;
|
}
|
|
/// <summary>
|
/// Add a TRIX indicator chart.
|
/// </summary>
|
/// <param name="height">The height of the indicator chart in pixels.</param>
|
/// <param name="period">The period to compute the indicator.</param>
|
/// <param name="color">The color of the indicator line.</param>
|
/// <returns>The XYChart object representing the chart created.</returns>
|
public: XYChart* addTRIX(int height, int period, int color)
|
{
|
double f = 2.0 / (period + 1);
|
char buffer[1024];
|
sprintf(buffer, "TRIX (%d)", period);
|
return addLineIndicator(height, ArrayMath(m_closeData).expAvg(f).expAvg(f).expAvg(f)
|
.rate().sub(1).mul(100), color, buffer);
|
}
|
|
private: ArrayMath computeTrueLow()
|
{
|
//the lower of today's low or yesterday's close.
|
ArrayMath previousClose = ArrayMath(m_closeData).shift();
|
DoubleArray previousCloseData = previousClose.result();
|
double *ret = new double[m_lowData.len];
|
|
for(int i = 0; i < m_lowData.len; ++i) {
|
if ((m_lowData[i] != Chart::NoValue) && (previousCloseData[i] != Chart::NoValue)) {
|
if (m_lowData[i] < previousCloseData[i]) {
|
ret[i] = m_lowData[i];
|
} else {
|
ret[i] = previousCloseData[i];
|
}
|
} else {
|
ret[i] = Chart::NoValue;
|
}
|
}
|
|
ArrayMath ret1(DoubleArray(ret, m_lowData.len));
|
delete[] ret;
|
return ret1;
|
}
|
|
/// <summary>
|
/// Add an Ultimate Oscillator indicator chart.
|
/// </summary>
|
/// <param name="height">The height of the indicator chart in pixels.</param>
|
/// <param name="period1">The first moving average period to compute the indicator.</param>
|
/// <param name="period2">The second moving average period to compute the indicator.</param>
|
/// <param name="period3">The third moving average period to compute the indicator.</param>
|
/// <param name="color">The color of the indicator line.</param>
|
/// <param name="range">The distance beween the middle line and the upper and lower threshold lines.</param>
|
/// <param name="upColor">The fill color when the indicator exceeds the upper threshold line.</param>
|
/// <param name="downColor">The fill color when the indicator falls below the lower threshold line.</param>
|
/// <returns>The XYChart object representing the chart created.</returns>
|
public: XYChart* addUltimateOscillator(int height, int period1, int period2, int period3,
|
int color, double range, int upColor, int downColor)
|
{
|
ArrayMath trueLow = computeTrueLow();
|
ArrayMath buyingPressure = ArrayMath(m_closeData).sub(trueLow);
|
ArrayMath trueRange = computeTrueRange();
|
|
ArrayMath rawUO1 = ArrayMath(buyingPressure).movAvg(period1).financeDiv(ArrayMath(trueRange
|
).movAvg(period1), 0.5).mul(4);
|
ArrayMath rawUO2 = ArrayMath(buyingPressure).movAvg(period2).financeDiv(ArrayMath(trueRange
|
).movAvg(period2), 0.5).mul(2);
|
ArrayMath rawUO3 = ArrayMath(buyingPressure).movAvg(period3).financeDiv(ArrayMath(trueRange
|
).movAvg(period3), 0.5).mul(1);
|
|
XYChart *c = addIndicator(height);
|
char buffer[1024];
|
sprintf(buffer, "Ultimate Oscillator (%d, %d, %d)", period1, period2, period3);
|
LineLayer *layer = addLineIndicator2(c, ArrayMath(rawUO1).add(rawUO2).add(rawUO3).mul(100.0
|
/ 7), color, buffer);
|
addThreshold(c, layer, 50 + range, upColor, 50 - range, downColor);
|
|
c->yAxis()->setLinearScale(0, 100);
|
return c;
|
}
|
|
/// <summary>
|
/// Add a Volume indicator chart.
|
/// </summary>
|
/// <param name="height">The height of the indicator chart in pixels.</param>
|
/// <param name="upColor">The color to used on an 'up' day. An 'up' day is a day where
|
/// the closing price is higher than that of the previous day.</param>
|
/// <param name="downColor">The color to used on a 'down' day. A 'down' day is a day
|
/// where the closing price is lower than that of the previous day.</param>
|
/// <param name="flatColor">The color to used on a 'flat' day. A 'flat' day is a day
|
/// where the closing price is the same as that of the previous day.</param>
|
/// <returns>The XYChart object representing the chart created.</returns>
|
public: XYChart* addVolIndicator(int height, int upColor, int downColor, int flatColor)
|
{
|
XYChart *c = addIndicator(height);
|
addVolBars2(c, height, upColor, downColor, flatColor);
|
return c;
|
}
|
|
/// <summary>
|
/// Add a William %R indicator chart.
|
/// </summary>
|
/// <param name="height">The height of the indicator chart in pixels.</param>
|
/// <param name="period">The period to compute the indicator.</param>
|
/// <param name="color">The color of the indicator line.</param>
|
/// <param name="range">The distance beween the middle line and the upper and lower threshold lines.</param>
|
/// <param name="upColor">The fill color when the indicator exceeds the upper threshold line.</param>
|
/// <param name="downColor">The fill color when the indicator falls below the lower threshold line.</param>
|
/// <returns>The XYChart object representing the chart created.</returns>
|
public: XYChart* addWilliamR(int height, int period, int color, double range, int upColor,
|
int downColor)
|
{
|
ArrayMath movLow = ArrayMath(m_lowData).movMin(period);
|
ArrayMath movHigh = ArrayMath(m_highData).movMax(period);
|
ArrayMath movRange = ArrayMath(movHigh).sub(movLow);
|
|
XYChart *c = addIndicator(height);
|
LineLayer *layer = addLineIndicator2(c, ArrayMath(movHigh).sub(m_closeData).financeDiv(
|
movRange, 0.5).mul(-100), color, "William %%R");
|
addThreshold(c, layer, -50 + range, upColor, -50 - range, downColor);
|
c->yAxis()->setLinearScale(-100, 0);
|
return c;
|
}
|
|
};
|
|
#ifdef _MSC_VER
|
#pragma warning(pop)
|
#endif
|
|
#endif
|
