#BonBon - Heiken_Ashi based on Sylvan Verboort's Trading with HA Candlestick Oscillator
#Bon Bon _last update 2/1/2021, Jan 17th 2021,
#Influenced by script from HoboTheClown / blt,http://www.thinkscripter.com, TD Hacolt etc., Thinkscript Cloud, TOS & Thinkscript Collection
#update 1/2/21 - changed the default moving average to TEMA. Changed the period to 35.
#update changed reversal arrows to reversal bubbles with price
#PLEASE DO NOT REMOVE THE HASHTAGS!!!! ONLY REMOVE THEM IF YOU PLAN ON USING THAT PARTICULAR SIGNAL. THERE ARE 3 DIFFERENT SIGNALS IN THE SCRIPT!!!!! IF YOU REMOVE ALL THE HASHTAGS YOU WILL HAVE NUMEROUS SIGNALS ON YOUR CHART!!!!!!!!!
input averagelength = 34;
input percentamount = .01;
input revAmount = .05;
input atrlength = 4;
input period = 50;
input hideCandles = no;
input show_bubble_labels = yes;
input bubbles = yes;
input arrows = yes;
input PaintBars = yes; #Update to add paintbars
input candleSmoothing = {default Valcu, Vervoort};
input movingAverageType = {default TEMA, Hull, Exponential};
def openMA;
def closeMA;
def highMA;
def lowMA;
switch (movingAverageType) {
case Exponential:
openMA = CompoundValue(1, ExpAverage(open, period), open);
closeMA = CompoundValue(1, ExpAverage(close, period), close);
highMA = CompoundValue(1, ExpAverage(high, period), high);
lowMA = CompoundValue(1, ExpAverage(low, period), low);
case Hull:
openMA = CompoundValue(1, HullMovingAvg(open, period), open);
closeMA = CompoundValue(1, HullMovingAvg(close, period), close);
highMA = CompoundValue(1, HullMovingAvg(high, period), high);
lowMA = CompoundValue(1, HullMovingAvg(low, period), low);
case TEMA:
openMA = CompoundValue(1, TEMA(open, period), open);
closeMA = CompoundValue(1, TEMA(close, period), close);
highMA = CompoundValue(1, TEMA(high, period), high);
lowMA = CompoundValue(1, TEMA(low, period), low);
}
HidePricePlot(hideCandles);
def haOpen;
def haClose;
switch (candleSmoothing){
case Valcu:
haOpen = CompoundValue(1, ( (haOpen[1] + (openMA[1] + highMA[1] + lowMA[1] + closeMA[1]) / 4.0) / 2.0), open);
haClose = ((((openMA + highMA + lowMA + closeMA) / 4.0) + haOpen + Max(highMA, haOpen) + Min(lowMA, haOpen)) / 4.0);
case Vervoort:
haOpen = CompoundValue(1, ( (haOpen[1] + (openMA[1] + highMA[1] + lowMA[1] + closeMA[1]) / 4.0 ) / 2.0), open);
haClose = ((((openMA + highMA + lowMA + closeMA) / 4.0) + haOpen + Max(highMA, haOpen) + Min(lowMA, haOpen)) / 4.0);
}
plot o = haOpen ;
o.Hide();
def haLow = Min(lowMA, haOpen);
def haHigh = Max(highMA, haOpen);
#############################################################################################
#Medium-term price reversals - upward trend
def avg = 34;
def TMA1 = reference TEMA(haClose, avg); # triple exponential moving average (TEMA) of 34 bars
def TMA2 = reference TEMA(TMA1, avg);
def Diff = TMA1 - TMA2;
def ZlHa = TMA1 + Diff; #Zero-lagging TEMA average on closing prices - medium term uptrend; plot line magenta
#def shortCandle = BodyHeight() < (high - low) * candleSizeFactor; #code taken from HACOLT
#Medium-term price reversals - downward trend
def avg2 = 34;
def TMA1_ = reference TEMA((high + low) / 2, avg2);
def Diff2 = TMA1_ - TMA2;
def ZlCl = TMA1_ + Diff2; #Zero-lagging TEMA average on closing prices - medium term doenwardtrend ....plot line yellow;
def ZlDif = ZlCl - ZlHa; # Zero-Lag close - Zero-Lag HA(green candle) Uptrend when ZlDif is equal to or greater than zero
#AssignPriceColor(if haclose >= haopen
# then Color.GREEN else
# if haclose < haopen
# then Color.RED else color.white);
#####################################################################################################
input charttype = ChartType.CANDLE;
def haopen_ = if haClose <= haOpen
then haOpen + 0
else Double.NaN;
def HAhi = if haClose <= haOpen
then haHigh
else Double.NaN;
def HAlo = if haClose <= haOpen
then haLow
else Double.NaN;
AddChart(growColor = Color.RED, neutralColor = Color.CURRENT, high = HAhi, low = HAlo, open = haopen_, close = haClose, type = ChartType.CANDLE);
def HAclose1 = ohlc4;
def HAopen1 = if haClose >= haOpen
then CompoundValue(1, (haOpen[1] + haClose[1]) / 2, (open[1] + close[1]) / 2)
else Double.NaN;
def haopen_1 = if haOpen <= haClose
then HAopen1 + 0 else Double.NaN;
def HAhigh1 = haHigh;
def HAlow1 = haLow;
AddChart(growColor = Color.GREEN, neutralColor = Color.CURRENT, high = HAhigh1, low = HAlow1, open = haopen_1, close = haClose, type = ChartType.CANDLE);
#####################################################################################################
def trend = if haclose >= haopen then 1 else 0; # halow1[-50]
#plot trendup = trend and !trend[1];
#trendup.SetPaintingStrategy(PaintingStrategy.BOOLEAN_ARROW_UP);
#trendup.SetDefaultColor(Color.GREEN);
#trendup.SetLineWeight(5);
def Trendd = if haclose < haopen then 1 else 0;
#plot trendDown = Trendd and !Trendd[1] ;
#trendDown.SetDefaultColor(Color.RED);
#trendDown.SetPaintingStrategy(PaintingStrategy.BOOLEAN_ARROW_DOWN);
#trendDown.SetLineWeight(5);
#AddChartBubble(bubbles and trendup and trendup , HAlow1, ("R$:" + Round(HAlow1, 2)), Color.CYAN, no);
#AddChartBubble(bubbles and trendDown and trendDown , HAhi, ("R$:" + Round(HAhi, 2)), Color.CYAN, yes);
########################################################################
End of HA_Smoothing Script
Signals
Original code by Taz43
#updated by BonBon 1/15/21 inccreased swing_back periods, changed "high and Low to Halow1 and Hahigh1". Included price labels/bubbles.
def bubbles2 = yes;
input swing_back = 20;
input swing_forward = 34;
input swinglow_back = 20;
input swinglow_forward =34;
input maxbars = 50;
input showlevels = Yes;
def sb = swing_back;
def sf = swing_forward;
def sb2 = swinglow_back;
def sf2 = swinglow_forward;
def na = Double.NaN;
def Offset4 = 8; # high(period = "day")and low(period = "day" ) and close(period = "day" ) * 0.03;
def bubblelocation = bubbles2[offset4];
def lfor2 = Lowest(halow, sf2)[-sf2]; #Remember that a negative number inside the square brackets means "after" this bar. So, the above line is defining "lfor" as being the lowest value of the two bars after this bar.
def lback2 = Lowest(halow, sb2)[1]; #This line of code is defining "lback" as the lowest value of the eight bars before this one.
def swinglow2 = if halow < lfor2 and halow < lback2 then 1 else 0;
#Finally, this line is actually defining what a "swing low" is. It says, if the low of this bar is lower than the two bars after this one AND the low of this bar is also lower than or equal to the lowest of the previous eight bars, then this bar is a swing low. So, what that means is that in order to determine whether a point on the chart is either a swing high or a swing low, it must have eight bars before the bar in question, as well as, two bars after it. Looking at the picture above, it can be seen that point "A" is a "swing high" because it is higher than the 8 bars before it AND it is higher than the 2 bars after it. Likewise, point "C" is a "swing low" because it is lower than the 8 bars before it AND it is lower than the 2 bars after it. (I know it's a line chart, not a bar chart. smiling smiley Just work with me here.)
plot sl = if swinglow2 then halow else na;
#sl.SetPaintingStrategy(PaintingStrategy.POINTS);
sl.SetDefaultColor(Color.WHITE);
sl.SetLineWeight(5);
def hfor = Highest(hahigh, sf)[-sf];
def hback = Highest(hahigh, sb)[1];
def swinghigh2 = if hahigh > hfor and hahigh > hback then 1 else 0;
plot sh = if swinghigh2 then hahigh else na ;
#sh.SetDefaultColor(Color.orange);
#sh.SetPaintingStrategy(PaintingStrategy.POINTS);
sh.SetLineWeight(5);
plot fh = if swinghigh2 then hahigh else na ;
fh.SetDefaultColor(Color.magenta);
#fh.SetPaintingStrategy(PaintingStrategy.booleaN_ARROW_DOWN);
fh.SetLineWeight(5);
plot fl = if swinglow2 then halo else na;
#fl.SetPaintingStrategy(PaintingStrategy.boolean_ARROW_UP);
fl.SetDefaultColor(Color.lime);
fl.SetLineWeight(5);
AddChartBubble(bubbles2 and fl and fl , HAlo, ("$:" + Round(HAlo, 2)), Color.lime, no);
AddChartBubble(bubbles2 and fh and fh , HAhigh, ("$:" + Round(HAhigh, 2)), Color.magenta, yes);
#######################################################################
Signals
###Ameritrade Thinkscript
#ZigZagHighLow High Low
#updated by BonBon 1/18/21 inccreased pivot lengths and periods, changed "high and Low to Halow1 and Hahigh1". Included price labels/bubbles.
def priceH = HAhigh1;
def priceL = HAlow1;
input atrreversal = 2.0;
def atr_atrreversal = atrreversal;
input tickReversal = 0;
#The minimum percentage of price change for a swing to be detected.
input percentageReversal = 5.0;
#Additional value in dollars that can be added to the minimum price change and ATR change to increase the distance between swing points.
input absoluteReversal = 0.0;
#The period for ATR calculation.
#input atrLength = 5;
#The factor by which the ATR value is multiplied.
#input atrReversal = 1.5;
#tick reversal- Additional value in ticks that can be added to the minimum price change and ATR change to increase the distance between swing points.
#input tickReversal = 0;
Assert(percentageReversal >= 0, "'percentage reversal' must not be negative: " + percentageReversal);
Assert(absoluteReversal >= 0, "'absolute reversal' must not be negative: " + absoluteReversal);
Assert(atrreversal >= 0, "'atr reversal' must not be negative: " + atrreversal);
Assert(percentageReversal != 0 or absoluteReversal != 0 or atrreversal != 0 or tickReversal != 0, "Either 'percentage reversal' or 'absolute reversal' or 'atr reversal' or 'tick reversal' must not be zero");
#Additional value in dollars that can be added to the minimum price change and ATR change to increase the distance between swing points.
def absReversal;
if (absoluteReversal != 0) {
absReversal = absoluteReversal;
} else {
absReversal = tickReversal * TickSize();
}
def hlPivot;
if (atrreversal != 0) {
hlPivot = percentageReversal / 300 + WildersAverage(TrueRange(haHigh, haClose, haLow), atrlength) / haClose * atrreversal;
} else {
hlPivot = percentageReversal / 300;
}
def state = {default init, undefined, uptrend, downtrend};
def maxPriceH;
def minPriceL;
def newMax;
def newMin;
def prevMaxH = GetValue(maxPriceH, 1);
def prevMinL = GetValue(minPriceL, 1);
if GetValue(state, 1) == GetValue(state.init, 0) {
maxPriceH = priceH;
minPriceL = priceL;
newMax = yes;
newMin = yes;
state = state.undefined;
} else if GetValue(state, 1) == GetValue(state.undefined, 0) {
if priceH >= prevMaxH {
state = state.uptrend;
maxPriceH = priceH;
minPriceL = prevMinL;
newMax = yes;
newMin = no;
} else if priceL <= prevMinL {
state = state.downtrend;
maxPriceH = prevMaxH;
minPriceL = priceL;
newMax = no;
newMin = yes;
} else {
state = state.undefined;
maxPriceH = prevMaxH;
minPriceL = prevMinL;
newMax = no;
newMin = no;
}
} else if GetValue(state, 1) == GetValue(state.uptrend, 0) {
if priceL <= prevMaxH - prevMaxH * hlPivot - absReversal {
state = state.downtrend;
maxPriceH = prevMaxH;
minPriceL = priceL;
newMax = no;
newMin = yes;
} else {
state = state.uptrend;
if (priceH >= prevMaxH) {
maxPriceH = priceH;
newMax = yes;
} else {
maxPriceH = prevMaxH;
newMax = no;
}
minPriceL = prevMinL;
newMin = no;
}
} else {
if priceH >= prevMinL + prevMinL * hlPivot + absReversal {
state = state.uptrend;
maxPriceH = priceH;
minPriceL = prevMinL;
newMax = yes;
newMin = no;
} else {
state = state.downtrend;
maxPriceH = prevMaxH;
newMax = no;
if (priceL <= prevMinL) {
minPriceL = priceL;
newMin = yes;
} else {
minPriceL = prevMinL;
newMin = no;
}
}
}
def barNumber = BarNumber();
def barCount = HighestAll(If(IsNaN(priceH), 0, barNumber));
def newState = GetValue(state, 0) != GetValue(state, 1);
def offset = barCount - barNumber + 1;
def highPoint = state == state.uptrend and priceH == maxPriceH;
def lowPoint = state == state.downtrend and priceL == minPriceL;
plot lastH;
if highPoint and offset > 1 {
lastH = fold iH = 1 to offset with tH = priceH while !IsNaN(tH) and !GetValue(newState, -iH) do if GetValue(newMax, -iH) or iH == offset - 1 and GetValue(priceH, -iH) == tH then Double.NaN else tH;
} else {
lastH = Double.NaN;
}
plot lastL;
if lowPoint and offset > 1 {
lastL = fold iL = 1 to offset with tL = priceL while !IsNaN(tL) and !GetValue(newState, -iL) do if GetValue(newMin, -iL) or iL == offset - 1 and GetValue(priceL, -iL) == tL then Double.NaN else tL;
} else {
lastL = Double.NaN;
}
#Zig Zag Line
#def HA;
#if barNumber == 1 {
# HA = fold iF = 1 to offset with tP = Double.NaN while IsNaN(tP) do if GetValue(state, -iF) == #GetValue(state.uptrend, 0) then priceL else if GetValue(state, -iF) == GetValue(state.downtrend, 0) #then priceH else Double.NaN;
#} else if barNumber == barCount {
# HA = if highPoint or state == state.downtrend and priceL > minPriceL then priceH else if lowPoint #or state == state.uptrend and priceH < maxPriceH then priceL else Double.NaN;
#} else {
# HA = if !IsNaN(lastH) then lastH else if !IsNaN(lastL) then lastL else Double.NaN;
#}
#HA.SetDefaultColor(GetColor(1));
#HA.EnableApproximation();
#plots up and down arrows
#lasth.SetPaintingStrategy(PaintingStrategy.BOOLEAN_ARROW_DOWN);
#lasth.SetDefaultColor(Color.yellow);
#lasth.SetLineWeight(5);
#lastl.SetPaintingStrategy(PaintingStrategy.BOOLEAN_ARROW_UP);
#lastl.SetDefaultColor(Color.yellow);
#lastl.SetLineWeight(5);
#AddChartBubble(bubbles and lastL and lastL, HAlow1, ("$:" + Round(HAlow1, 2)), Color.YELLOW, no);
#AddChartBubble(bubbles and lastH and lastH, HAhigh1, ("$:" + Round(HAhigh1, 2)), Color.YELLOW, yes);
####################################################################################
Signals
#Thinkscript cloud - Mobius/Robert Payne
#updated BonBon 1/26/2021 - changed the default settings for the swinglows. Also changed to incorporate the HA Smoothing charttype settings.
#Here is the script for swing high and swing low. Swing high is marked by red arrow and swing low by green arrow. You can change it to dots by changing boolean_arrow_down to points. You can change the size by changing setlineweight to 2,3,4, or 5. The default setting to determine swing high/low is 3 candles but you can change that in edit properties.
input HA_swinglow = 45;
input HA_swinghigh = 45;
# define and plot the most recent high
def HA_trend = hahigh1 >= Highest(hahigh1[1],HA_swinghigh) and hahigh1 >= Highest(hahigh1[- HA_swinghigh], HA_swinghigh);
def HA_signal1 = if BarNumber() < HA_swinghigh then Double.NaN else if HA_trend then hahigh1 else Double.NaN;
plot HATrend = HA_signal1;
#HATrend.SetPaintingStrategy(PaintingStrategy.BOOLEAN_ARROW_DOWN);
HATrend.SetDefaultColor(Color.DOWNTICK);
HATrend.SetLineWeight(5);
# define and plot the most recent low
def HA_trend2 = halow1 <= Lowest(halow1[1], HA_swinglow) and halow1 <= Lowest(halow1[- HA_swinglow], HA_swinglow);
def HA_signal2 = if BarNumber() < HA_swinglow then Double.NaN else if HA_trend2 then halow1 else Double.NaN;
plot HATrend2 = HA_signal2;
# HATrend2.SetPaintingStrategy(PaintingStrategy.BOOLEAN_ARROW_UP);
# HATrend2.SetDefaultColor(Color.UPTICK);
# HATrend2.SetLineWeight(5);
#AddChartBubble(bubbles and HATrend2 and HATrend2, HAlow1, ("$:" + Round(HAlow1, 2)), Color.lime, no);
#AddChartBubble(bubbles and HATrend and HATrend, HAhigh1, ("$:" + Round(HAhigh1, 2)), Color.magenta, yes);
#End code
#################################################
Multi-Time Frame Script for the lower chart
# Multi time-frame Heikin
#BonBon 1/29/21
# Four hours and Day MTF not included in the top plot. Three or more of the indicators must be green or red to plot.
declare lower;
input UsePeriod5 = AggregationPeriod.FIVE_MIN;
input UsePeriod15 = AggregationPeriod.FIFTEEN_MIN;
input UsePeriod30 = AggregationPeriod.thirty_MIN;
input UsePeriod60 = AggregationPeriod. HOUR;
input UsePeriod4hr = AggregationPeriod. FOUR_HOURS;
input UsePeriodday = AggregationPeriod.DAY;
input Con_Cri = 3;
input Main_Heikin_Plot = Yes;
#Timeframe1 5 min
def aOpen5 = open(period = UsePeriod5);
def aClose5 = close(period = UsePeriod5);
def aHigh5 = high(period = UsePeriod5);
def aLow5 = low(period = UsePeriod5);
def haClose5 = (aOpen5 + aClose5 + aHigh5 + aLow5) / 4;
def haOpen5 = (haOpen5[1] + haClose5[1]) / 2;
def trend5 = if haClose5 >= haOpen5 then 1 else if haClose5[1] < haOpen5[1] then -1 else 0;
plot HA_Up5 = if IsNaN(UsePeriod5) then Double.NaN else 6;
HA_Up5.SetPaintingStrategy(PaintingStrategy.POINTS);#SetStyle(curve.Points);
HA_Up5.AssignValueColor(if haClose5 >= haOpen5 then Color.GREEN else if haClose5[1] < haOpen5[1] then Color.RED else Color.CURRENT);
HA_Up5.SetLineWeight(4);
############################################
#Timeframe2 15 mins
def aOpen15 = open(period = UsePeriod15);
def aClose15 = close(period = UsePeriod15);
def aHigh15 = high(period = UsePeriod15);
def aLow15 = low(period = UsePeriod15);
def haClose15 = (aOpen15 + aClose15 + aHigh15 + aLow15) / 4;
def haOpen15 = (haOpen15[1] + haClose15[1]) / 2;
def trend15 = if haClose15 >= haOpen15 then 1 else if haClose15[1] < haOpen15[1] then -1 else 0;
plot HA_Up15 = if IsNaN(UsePeriod15) then Double.NaN else 5;
#plot HA_Up15 = if haClose15 >= haOpen15 then 1 else 0;
HA_Up15.SetPaintingStrategy(PaintingStrategy.Points);#SetStyle(Curve.POINTS);
HA_Up15.AssignValueColor(if haClose15 >= haOpen15 then Color.GREEN else if haClose15 [1]< haOpen15[1] then Color.RED else Color.CURRENT);
HA_Up15.SetLineWeight(4);
#######################################
#Timeframe3 30 mins
def aOpen30 = open(period = UsePeriod30);
def aClose30 = close(period = UsePeriod30);
def aHigh30 = high(period = UsePeriod30);
def aLow30 = low(period = UsePeriod30);
def haClose30 = (aOpen30 + aClose30 + aHigh30 + aLow30) / 4;
def haOpen30 = (haOpen30[1] + haClose30[1]) / 2;
def trend30 = if haClose30 >= haOpen30 then 1 else if haClose30[1] < haOpen30[1] then -1 else 0;
plot HA_Up30 = if IsNaN(UsePeriod30) then Double.NaN else 4;
#plot HA_Up60 = if haClose60 >= haOpen60 then 1 else 0;
HA_Up30.SetPaintingStrategy(PaintingStrategy.Points);#SetStyle(Curve.POINTS);
HA_Up30.AssignValueColor(if haClose30 >= haOpen30 then Color.GREEN else if haClose30[1] < haOpen30[1] then Color.RED else Color.CURRENT);
HA_Up30.SetLineWeight(4);
################################
#Timeframe4 60mins
def aOpen60 = open(period = UsePeriod60);
def aClose60 = close(period = UsePeriod60);
def aHigh60 = high(period = UsePeriod60);
def aLow60 = low(period = UsePeriod60);
def haClose60 = (aOpen60 + aClose60 + aHigh60 + aLow60) / 4;
def haOpen60 = (haOpen60[1] + haClose60[1]) / 2;
def trend60 = if haClose60 >= haOpen60 then 1 else if haClose60[1] < haOpen60[1] then -1 else 0;
plot HA_Up60 = if IsNaN(UsePeriod60) then Double.NaN else 3;
#plot HA_Up60 = if haClose60 >= haOpen60 then 1 else 0;
HA_Up60.SetPaintingStrategy(PaintingStrategy.Points);#SetStyle(Curve.POINTS);
HA_Up60.AssignValueColor(if haClose60 >= haOpen60 then Color.GREEN else if haClose60[1] < haOpen60[1] then Color.RED else Color.CURRENT);
HA_Up60.SetLineWeight(4);
##################################
#Timeframe5 4hrs
def aOpen4hr = open(period = UsePeriod4hr);
def aClose4hr = close(period = UsePeriod4hr);
def aHigh4hr = high(period = UsePeriod4hr);
def aLow4hr = low(period = UsePeriod4hr);
def haClose4hr = (aOpen4hr + aClose4hr + aHigh4hr + aLow4hr) / 4;
def haOpen4hr = (haOpen4hr[1] + haClose4hr[1]) / 2;
def trend4hr = if haClose4hr >= haOpen4hr then 1 else if haClose4hr < haOpen4hr then -1 else 0;
plot HA_Up4hr = if IsNaN(UsePeriod4hr) then Double.NaN else 2;
#plot HA_Up60 = if haClose60 >= haOpen60 then 1 else 0;
HA_Up4hr.SetPaintingStrategy(PaintingStrategy.Points);#SetStyle(Curve.POINTS);
HA_Up4hr.AssignValueColor(if haClose4hr >= haOpen4hr then Color.GREEN else if haClose4hr[1] < haOpen4hr[1] then Color.RED else Color.CURRENT);
HA_Up4hr.SetLineWeight(4);
#######################################
#Timeframe6 Day
def aOpenday = open(period = UsePeriodday);
def aCloseday = close(period = UsePeriodday);
def aHighday = high(period = UsePeriodday);
def aLowday = low(period = UsePeriodday);
def haCloseday = (aOpenday + aCloseday + aHighday + aLowday) / 4;
def haOpenday = (haOpenday[1] + haCloseday[1]) / 2;
def trendday = if haCloseday >= haOpenday then 1 else if haCloseday [1] < haOpenday[1] then -1 else 0;
plot HA_Upday = if IsNaN(UsePeriodday) then Double.NaN else 1;
#plot HA_Up60 = if haClose60 >= haOpen60 then 1 else 0;
HA_Upday.SetPaintingStrategy(PaintingStrategy.Points);#SetStyle(Curve.POINTS);
HA_Upday.AssignValueColor(if haCloseday >= haOpenday then Color.GREEN else if haCloseday[1] < haOpenday[1] then Color.RED else Color.CURRENT);
HA_Upday.SetLineWeight(4);
####################################
#def Trend1 = if haClose5 >= haOpen5 then 1 else if haClose5[1] < haOpen5[1] then -1 else 0;
#def Trend2 = if haClose15 >= haOpen15 then 1 else if haClose15[1] < haOpen15[1] then -1 else 0;
#def Trend3 = if haClose60 >= haOpen60 then 1 else if haClose60[1] < haOpen60[1] then -1 else 0;
#def Trend4 = if haClose4hr >= haOpen4hr then 1 else if haClose4hr[1] < haOpen4hr[1] then -1 else 0;
#def Trend5_ = if haCloseday >= haOpenday then 1 else if haCloseday[1] < haOpenday[1] then -1 else 0;
#Down Trend
#def Trend1a = if haClose5 < haOpen5 then 1 else if haClose5[1] >= haOpen5[1] then -1 else 0;
#def Trend2b = if haClose15 < haOpen15 then 1 else if haClose15[1] >= haOpen15[1] then -1 else 0;
#def Trend3c = if haClose60 < haOpen60 then 1 else if haClose60[1]>= haOpen60[1] then -1 else 0;
#def Trend4d = if haClose4hr < haOpen4hr then 1 else if haClose4hr[1] >= haOpen4hr[1] then -1 else 0;
#def Trend5e = if haCloseday < haOpenday then 1 else if haCloseday[1] >= haOpenday[1] then -1 else 0;
#Up Trend
def Trend1 = if haClose5 >= haOpen5 then 1 else if haClose5[1] < haOpen5[1] then -1 else 0;
def Trend2 = if haClose15 >= haOpen15 then 1 else if haClose15[1] < haOpen15[1] then -1 else 0;
def Trend3 = if haClose30>= haOpen30 then 1 else if haClose30[1] < haOpen30[1] then -1 else 0;
def Trend4 = if haClose60 >= haOpen60 then 1 else if haClose60[1] < haOpen60[1] then -1 else 0;
def Trend5_ = if haClose4hr >= haOpen4hr then 1 else if haClose4hr[1] < haOpen4hr[1] then -1 else 0;
def Trend6 = if haCloseday >= haOpenday then 1 else if haCloseday[1] < haOpenday[1] then -1 else 0;
#Down Trend
def Trend1a = if haClose5 < haOpen5 then 1 else if haClose5[1] >= haOpen5[1] then -1 else 0;
def Trend2b = if haClose15 < haOpen15 then 1 else if haClose15[1] >= haOpen15[1] then -1 else 0;
def Trend3c = if haClose30 < haOpen30 then 1 else if haClose30[1] >= haOpen30[1] then -1 else 0;
def Trend4d = if haClose60 < haOpen60 then 1 else if haClose60[1] >= haOpen60[1] then -1 else 0;
def Trend5e= if haClose4hr < haOpen4hr then 1 else if haClose4hr[1] >= haOpen4hr[1] then -1 else 0;
def Trend6f = if haCloseday < haOpenday then 1 else if haCloseday[1] >= haOpenday[1] then -1 else 0;
#plot MTF_TREND = 6;
#MTF_TREND.SetPaintingStrategy(PaintingStrategy.Points);
#MTF_TREND.SetLineWeight(lineWeight = 3);
#MTF_TREND.DefineColor("Buy", GetColor(5));
#MTF_TREND.DefineColor("Sell", GetColor(6));
#MTF_TREND.AssignValueColor(if (Trend1 + Trend2 + Trend3 + Trend4 + Trend5_) >= 3 then Color.GREEN else Color.RED);
#MTF_TREND.AssignValueColor(if PaintBars is false and (Trend1 + Trend2 + Trend3 + Trend4 + Trend5_) >= 3 #then Color.GREEN else if PaintBars is false and (Trend1 + Trend2 + Trend3 + Trend4 + Trend5_) < 3 then #Color. RED else Color.CURRENT);
def HA_MTF_TrendUP = (Trend1 + Trend2 + Trend3 + Trend4) >= Con_Cri ;
def HA_MTF_TrendDN = (Trend1a + Trend2b + Trend3c + Trend4d) >= Con_Cri;
plot Main_Heikin = 7;
Main_Heikin.SetPaintingStrategy(PaintingStrategy.POINTS);
Main_Heikin.AssignValueColor(if HA_MTF_TrendUP == 1 then Color.Green else if HA_MTF_TrendDN == 1 then color.red else Color.Black);
Main_Heikin.SetLineWeight(4);
#End code
#######################################################