Join useThinkScript to post your question to a community of 21,000+ developers and traders.
Good people... I also give you... C3_Big_Spark_MAX! (plus TS_V9! - signals only)
I took C3_Max_TS from the keyboard cowboy himself... @Christopher84 ... and merged The Big7 removed redundant code or just unneeded (is that a word?) code (per my use) including the profit loss code from TS_V9 which meant I would have to sacrifice the Average lines... which I shed a few tears over but it had to be done... The arrows for TS V9 can be enabled in settings. Also you will notice the consensus label has made its return indicating OBOS conditions. Other than that I changed some inputs to def so they would not appear in settings as most do not adjust them anyway including myself and I attempted to put them in an order that makes sense.
http://tos.mx/7KO43DU
Code:########################################################################################## ########################################################################################## ### ### ### ############################# ######### ######### ### ### ################################# ######### ######### ### ### #################################### ######### ######### ### ### ######## ######### ######### ######### ### ### ######## C3_BIG_SPARK_MAX ######### ######### ######### ### ### ######## +TSV9 ######### ######### ######### ### ### ######## @Christopher84 ######### ######### ######### ### ### ######## ######### ######### ######### ### ### ###################################### ################################## ### ### #################################### ################################## ### ### ################################# ################################## ### ### #################################### ################################## ### ### ######## ######### ######### ### ### ######## @Horserider ######### ######### ### ### ######## HORSERIDER VOLUME ######### ######### ### ### ######## TRIPLE EXHAUSTION ######### ######### ### ### ######## @chence27 ######### ######### ### ### ######## ######### ######### ### ### #################################### ######### ### ### ################################## ######### ### ### ############################### ######### ### ### ### ########################################################################################## ########################################################################################## input showverticallineday = yes; input show_ts_signals = no; input showLabels = yes; input showCloud = yes; input trailType = {default modified, unmodified}; input averagetype = AverageType.SIMPLE; input MACD_AverageType = {SMA, default EMA}; input DMI_averageType = AverageType.WILDERS; input AvgType = AverageType.HULL; input length9 = 35; input length8 = 10; input length10 = 20; input length_3x = 1000; input tradeDaytimeOnly = no; #hint tradeDaytimeOnly: (IntraDay Only) Only perform trades during hours stated input OpenTime = 0930; #hint OpenTime: Opening time of market input CloseTime = 1600; #hint CloseTime: Closing time of market input firstTrade = {default long, short}; input LongTrades = yes; #hint LongTrades: perform long trades input ShortTrades = yes; #hint ShortTrades: perform short trades input useStops = no; #hint useStops: use stop orders input useAlerts = no; #hint useAlerts: use alerts on signals input ATRPeriod = 11; input ATRFactor = 2.2; input ATRPeriod2 = 5; input ATRFactor2 = 1.5; input AtrMult = 1.0; input HideBoxLines = no; input HideCloud = no; input HideLabels = no; input Strategy_Confirmation_Factor = 4; input Strategy_FilterWithTMO = no; input Strategy_FilterWithTMO_arrows = yes; input Strategy_HoldTrend = no; input Strategy_ColoredCandlesOn = yes; input coloredCandlesOn = yes; input ColorPrice = yes; input color_blst = no; input color_3x = yes; input color_3xt = yes; input color_OBOS = no; input BarsUsedForRange = 2; input BarsRequiredToRemainInRange = 2; input TargetMultiple = 0.5; input trig = 20;# for Blast-off candle color def HideTargets = no; def HideBalance = no; ##################################################### #TS Strategy_V9 Created by Christopher84 08/10/2021 ##################################################### Assert(ATRFactor > 0, "'atr factor' must be positive: " + ATRFactor); def HiLo = Min(high - low, 1.5 * Average(high - low, ATRPeriod)); def HRef = if low <= high[1] then high - close[1] else (high - close[1]) - 0.5 * (low - high[1]); def LRef = if high >= low[1] then close[1] - low else (close[1] - low) - 0.5 * (low[1] - high); def trueRange; switch (trailType) { case modified: trueRange = Max(HiLo, Max(HRef, LRef)); case unmodified: trueRange = TrueRange(high, close, low); } def loss = ATRFactor * MovingAverage(averageType, trueRange, ATRPeriod); def state = {default init, long, short}; def trail; switch (state[1]) { case init: if (!IsNaN(loss)) { switch (firstTrade) { case long: state = state.long; trail = close - loss; case short: state = state.short; trail = close + loss; } } else { state = state.init; trail = Double.NaN; } case long: if (close > trail[1]) { state = state.long; trail = Max(trail[1], close - loss); } else { state = state.short; trail = close + loss; } case short: if (close < trail[1]) { state = state.short; trail = Min(trail[1], close + loss); } else { state = state.long; trail = close - loss; } } def price = close; def TrailingStop = trail; def LongEnter = (price crosses above TrailingStop); def LongExit = (price crosses below TrailingStop); #Addorder(OrderType.BUY_AUTO, condition = LongEnter, price = open[-1], 1, tickcolor = GetColor(1), arrowcolor = Color.LIME); #AddOrder(OrderType.SELL_AUTO, condition = LongExit, price = open[-1], 1, tickcolor = GetColor(2), arrowcolor = Color.LIME); def upsignal = (price crosses above TrailingStop); def downsignal = (price crosses below TrailingStop); ############################################### ##OB_OS_Levels_v5 by Christopher84 12/10/2021 ############################################### #def TrailingStop = trail; def H = Highest(TrailingStop, 12); def L = Lowest(TrailingStop, 12); def BulgeLengthPrice = 100; def SqueezeLengthPrice = 100; def BandwidthC3 = (H - L); #def IntermResistance2 = Highest(BandwidthC3, BulgeLengthPrice); def IntermSupport2 = Lowest(BandwidthC3, SqueezeLengthPrice); def sqzTrigger = BandwidthC3 <= IntermSupport2; def sqzLevel = if !sqzTrigger[1] and sqzTrigger then hl2 else if !sqzTrigger then Double.NaN else sqzLevel[1]; plot Squeeze_Alert = sqzLevel; Squeeze_Alert.SetPaintingStrategy(PaintingStrategy.POINTS); Squeeze_Alert.SetLineWeight(3); Squeeze_Alert.SetDefaultColor(Color.YELLOW); ############################################### ##Yellow Candle_height (OB_OS) ############################################### def displace = 0; def factorK2 = 3.25; def lengthK2 = 20; def price1 = open; def trueRangeAverageType = AverageType.SIMPLE; def ATR_length = 15; def SMA_lengthS = 6; def HiLo2 = Min(high - low, 1.5 * Average(high - low, ATRPeriod)); def HRef2 = if low <= high[1] then high - close[1] else (high - close[1]) - 0.5 * (low - high[1]); def LRef2 = if high >= low[1] then close[1] - low else (close[1] - low) - 0.5 * (low[1] - high); def loss2 = ATRFactor2 * MovingAverage(averageType, trueRange, ATRPeriod2); def multiplier_factor = 1.25; def valS = Average(price, SMA_lengthS); def average_true_range = Average(TrueRange(high, close, low), length = ATR_length); def Upper_BandS = valS[-displace] + multiplier_factor * average_true_range[-displace]; def Middle_BandS = valS[-displace]; def Lower_BandS = valS[-displace] - multiplier_factor * average_true_range[-displace]; def shiftK2 = factorK2 * MovingAverage(trueRangeAverageType, TrueRange(high, close, low), lengthK2); def averageK2 = MovingAverage(averageType, price, lengthK2); def AvgK2 = averageK2[-displace]; def Upper_BandK2 = averageK2[-displace] + shiftK2[-displace]; def Lower_BandK2 = averageK2[-displace] - shiftK2[-displace]; def condition_BandRevDn = (Upper_BandS > Upper_BandK2); def condition_BandRevUp = (Lower_BandS < Lower_BandK2); def fastLength = 12; def slowLength = 26; def MACDLength = 9; def fastEMA = ExpAverage(price, fastLength); def slowEMA = ExpAverage(price, slowLength); def Value; def Avg; switch (MACD_AverageType) { case SMA: Value = Average(price, fastLength) - Average(price, slowLength); Avg = Average(Value, MACDLength); case EMA: Value = fastEMA - slowEMA; Avg = ExpAverage(Value, MACDLength); } def Diff = Value - Avg; def MACDLevel = 0.0; def Level = MACDLevel; def condition1 = Value[1] <= Value; def condition1D = Value[1] > Value; #RSI def RSI_length = 14; def RSI_AverageType = AverageType.WILDERS; def RSI_OB = 70; def RSI_OS = 30; def NetChgAvg = MovingAverage(RSI_AverageType, price - price[1], RSI_length); def TotChgAvg = MovingAverage(RSI_AverageType, AbsValue(price - price[1]), RSI_length); def ChgRatio = if TotChgAvg != 0 then NetChgAvg / TotChgAvg else 0; def RSI = 50 * (ChgRatio + 1); def condition2 = (RSI[3] < RSI) is true or (RSI >= 80) is true; def condition2D = (RSI[3] > RSI) is true or (RSI < 20) is true; def conditionOB1 = RSI > RSI_OB; def conditionOS1 = RSI < RSI_OS; #MFI def MFI_Length = 14; def MFIover_Sold = 20; def MFIover_Bought = 80; def movingAvgLength = 1; def MoneyFlowIndex = Average(MoneyFlow(high, close, low, volume, MFI_Length), movingAvgLength); def MFIOverBought = MFIover_Bought; def MFIOverSold = MFIover_Sold; def condition3 = (MoneyFlowIndex[2] < MoneyFlowIndex) is true or (MoneyFlowIndex > 85) is true; def condition3D = (MoneyFlowIndex[2] > MoneyFlowIndex) is true or (MoneyFlowIndex < 20) is true; def conditionOB2 = MoneyFlowIndex > MFIover_Bought; def conditionOS2 = MoneyFlowIndex < MFIover_Sold; #Forecast def na = Double.NaN; def MidLine = 50; def Momentum = MarketForecast().Momentum; def NearT = MarketForecast().NearTerm; def Intermed = MarketForecast().Intermediate; def FOB = 80; def FOS = 20; def upperLine = 110; def condition4 = (Intermed[1] <= Intermed) or (NearT >= MidLine); def condition4D = (Intermed[1] > Intermed) or (NearT < MidLine); def conditionOB3 = Intermed > FOB; def conditionOS3 = Intermed < FOS; def conditionOB4 = NearT > FOB; def conditionOS4 = NearT < FOS; #Change in Price def lengthCIP = 5; def CIP = (price - price[1]); def AvgCIP = ExpAverage(CIP[-displace], lengthCIP); def CIP_UP = AvgCIP > AvgCIP[1]; def CIP_DOWN = AvgCIP < AvgCIP[1]; def condition5 = CIP_UP; def condition5D = CIP_DOWN; #EMA_1 def EMA_length = 8; def AvgExp = ExpAverage(price[-displace], EMA_length); def condition6 = (price >= AvgExp) and (AvgExp[2] <= AvgExp); def condition6D = (price < AvgExp) and (AvgExp[2] > AvgExp); #EMA_2 def EMA_2length = 20; def displace2 = 0; def AvgExp2 = ExpAverage(price[-displace2], EMA_2length); def condition7 = (price >= AvgExp2) and (AvgExp2[2] <= AvgExp); def condition7D = (price < AvgExp2) and (AvgExp2[2] > AvgExp); #DMI Oscillator def DMI_length = 5;#Typically set to 10 def diPlus = DMI(DMI_length, DMI_averageType)."DI+"; def diMinus = DMI(DMI_length, DMI_averageType)."DI-"; def Osc = diPlus - diMinus; def Hist = Osc; def ZeroLine = 0; def condition8 = Osc >= ZeroLine; def condition8D = Osc < ZeroLine; #Trend_Periods def TP_fastLength = 3;#Typically 7 def TP_slowLength = 4;#Typically 15 def Periods = Sign(ExpAverage(close, TP_fastLength) - ExpAverage(close, TP_slowLength)); def condition9 = Periods > 0; def condition9D = Periods < 0; #Polarized Fractal Efficiency def PFE_length = 5;#Typically 10 def smoothingLength = 2.5;#Typically 5 def PFE_diff = close - close[PFE_length - 1]; def val = 100 * Sqrt(Sqr(PFE_diff) + Sqr(PFE_length)) / Sum(Sqrt(1 + Sqr(close - close[1])), PFE_length - 1); def PFE = ExpAverage(if PFE_diff > 0 then val else -val, smoothingLength); def UpperLevel = 50; def LowerLevel = -50; def condition10 = PFE > 0; def condition10D = PFE < 0; def conditionOB5 = PFE > UpperLevel; def conditionOS5 = PFE < LowerLevel; #Bollinger Bands PercentB def BBPB_length = 20;#Typically 20 def Num_Dev_Dn = -2.0; def Num_Dev_up = 2.0; def BBPB_OB = 100; def BBPB_OS = 0; def upperBand = BollingerBands(price, displace, BBPB_length, Num_Dev_Dn, Num_Dev_up, averagetype).UpperBand; def lowerBand = BollingerBands(price, displace, BBPB_length, Num_Dev_Dn, Num_Dev_up, averagetype).LowerBand; def PercentB = (price - lowerBand) / (upperBand - lowerBand) * 100; def HalfLine = 50; def UnitLine = 100; def condition11 = PercentB > HalfLine; def condition11D = PercentB < HalfLine; def conditionOB6 = PercentB > BBPB_OB; def conditionOS6 = PercentB < BBPB_OS; def condition12 = (Upper_BandS[1] <= Upper_BandS) and (Lower_BandS[1] <= Lower_BandS); def condition12D = (Upper_BandS[1] > Upper_BandS) and (Lower_BandS[1] > Lower_BandS); #Klinger Histogram def Klinger_Length = 13; def KVOsc = KlingerOscillator(Klinger_Length).KVOsc; def KVOH = KVOsc - Average(KVOsc, Klinger_Length); def condition13 = (KVOH > 0); def condition13D = (KVOH < 0); #Projection Oscillator def ProjectionOsc_length = 30;#Typically 10 def MaxBound = HighestWeighted(high, ProjectionOsc_length, LinearRegressionSlope(price = high, length = ProjectionOsc_length)); def MinBound = LowestWeighted(low, ProjectionOsc_length, LinearRegressionSlope(price = low, length = ProjectionOsc_length)); def ProjectionOsc_diff = MaxBound - MinBound; def PROSC = if ProjectionOsc_diff != 0 then 100 * (close - MinBound) / ProjectionOsc_diff else 0; def PROSC_OB = 80; def PROSC_OS = 20; def condition14 = PROSC > 50; def condition14D = PROSC < 50; def conditionOB7 = PROSC > PROSC_OB; def conditionOS7 = PROSC < PROSC_OS; # AK Trend def aktrend_input1 = 3; def aktrend_input2 = 8; def aktrend_price = close; def aktrend_fastmaa = MovAvgExponential(aktrend_price, aktrend_input1); def aktrend_fastmab = MovAvgExponential(aktrend_price, aktrend_input2); def aktrend_bspread = (aktrend_fastmaa - aktrend_fastmab) * 1.001; def cond1_UP = if aktrend_bspread > 0 then 1 else 0; def cond1_DN = if aktrend_bspread <= 0 then -1 else 0; # ZSCORE def zscore_price = close; def zscore_length = 20; def zscore_ZavgLength = 20; def zscore_oneSD = StDev(zscore_price, zscore_length); def zscore_avgClose = SimpleMovingAvg(zscore_price, zscore_length); def zscore_ofoneSD = zscore_oneSD * zscore_price[1]; def zscore_Zscorevalue = ((zscore_price - zscore_avgClose) / zscore_oneSD); def zscore_avgZv = Average(zscore_Zscorevalue, 20); def zscore_Zscore = ((zscore_price - zscore_avgClose) / zscore_oneSD); def zscore_avgZscore = Average(zscore_Zscorevalue, zscore_ZavgLength); def cond2_UP = if zscore_Zscore > 0 then 1 else 0; def cond2_DN = if zscore_Zscore <= 0 then -1 else 0; # Ehlers def ehlers_length = 34; def ehlers_price = (high + low) / 2; def ehlers_coeff = ehlers_length * ehlers_price * ehlers_price - 2 * ehlers_price * Sum(ehlers_price, ehlers_length)[1] + Sum(ehlers_price * ehlers_price, ehlers_length)[1]; def ehlers_Ehlers = Sum(ehlers_coeff * ehlers_price, ehlers_length) / Sum(ehlers_coeff, ehlers_length); def cond3_UP = if close > ehlers_Ehlers then 1 else 0; def cond3_DN = if close <= ehlers_Ehlers then -1 else 0; # Anchored Momentum def amom_src = close; def amom_MomentumPeriod = 10; def amom_SignalPeriod = 8; def amom_SmoothMomentum = no; def amom_SmoothingPeriod = 7; def amom_p = 2 * amom_MomentumPeriod + 1; def amom_t_amom = if amom_SmoothMomentum == yes then ExpAverage(amom_src, amom_SmoothingPeriod) else amom_src; def amom_amom = 100 * ( (amom_t_amom / ( Average(amom_src, amom_p)) - 1)); def amom_amoms = Average(amom_amom, amom_SignalPeriod); def cond4_UP = if amom_amom > 0 then 1 else 0; def cond4_DN = if amom_amom <= 0 then -1 else 0; # TMO def tmo_length = 30; #def 14 def tmo_calcLength = 6; #def 5 def tmo_smoothLength = 6; #def 3 def tmo_data = fold i = 0 to tmo_length with s do s + (if close > GetValue(open, i) then 1 else if close < GetValue(open, i) then - 1 else 0); def tmo_EMA5 = ExpAverage(tmo_data, tmo_calcLength); def tmo_Main = ExpAverage(tmo_EMA5, tmo_smoothLength); def tmo_Signal = ExpAverage(tmo_Main, tmo_smoothLength); def tmo_color = if tmo_Main > tmo_Signal then 1 else -1; def cond5_UP = if tmo_Main <= 0 then 1 else 0; def cond5_DN = if tmo_Main >= 0 then -1 else 0; #Trend Confirmation Calculator def Confirmation_Factor = 7; #def Agreement_Level = condition1; def Agreement_LevelOB = 12; def Agreement_LevelOS = 2; def factorK = 2.0; def lengthK = 20; def shift = factorK * MovingAverage(trueRangeAverageType, TrueRange(high, close, low), lengthK); def averageK = MovingAverage(averageType, price, lengthK); def AvgK = averageK[-displace]; def Upper_BandK = averageK[-displace] + shift[-displace]; def Lower_BandK = averageK[-displace] - shift[-displace]; def conditionK1UP = price >= Upper_BandK; def conditionK2UP = (Upper_BandK[1] < Upper_BandK) and (Lower_BandK[1] < Lower_BandK); def conditionK3DN = (Upper_BandK[1] > Upper_BandK) and (Lower_BandK[1] > Lower_BandK); def conditionK4DN = price < Lower_BandK; def Agreement_Level = condition1 + condition2 + condition3 + condition4 + condition5 + condition6 + condition7 + condition8 + condition9 + condition10 + condition11 + condition12 + condition13 + condition14 + conditionK1UP + conditionK2UP; def Agreement_LevelD = (condition1D + condition2D + condition3D + condition4D + condition5D + condition6D + condition7D + condition8D + condition9D + condition10D + condition11D + condition12D + condition13D + condition14D + conditionK3DN + conditionK4DN); def Consensus_Level = Agreement_Level - Agreement_LevelD; def UP = Consensus_Level >= 6; def DOWN = Consensus_Level < -6; def priceColor = if UP then 1 else if DOWN then -1 else priceColor[1]; def Consensus_Level_OB = 14; def Consensus_Level_OS = -12; #Super_OB/OS Signal def OB_Level = conditionOB1 + conditionOB2 + conditionOB3 + conditionOB4 + conditionOB5 + conditionOB6 + conditionOB7; def OS_Level = conditionOS1 + conditionOS2 + conditionOS3 + conditionOS4 + conditionOS5 + conditionOS6 + conditionOS7; def Consensus_Line = OB_Level - OS_Level; def Zero_Line = 0; def Super_OB = 4; def Super_OS = -4; def DOWN_OB = (Agreement_Level > Agreement_LevelOB) and (Consensus_Line > Super_OB) and (Consensus_Level > Consensus_Level_OB); def UP_OS = (Agreement_Level < Agreement_LevelOS) and (Consensus_Line < Super_OS) and (Consensus_Level < Consensus_Level_OS); def OS_Buy = UP_OS; def OB_Sell = DOWN_OB; def neutral = Consensus_Line < Super_OB and Consensus_Line > Super_OS; def use_line_limits = yes;#Yes, plots line from/to; No, plot line across entire chart def linefrom = 100;#Hint linefrom: limits how far line plots in candle area def lineto = 12;#Hint lineto: limits how far into expansion the line will plot def YHOB = if coloredCandlesOn and ((price1 > Upper_BandS) and (condition_BandRevDn)) then high else Double.NaN; def YHOS = if coloredCandlesOn and ((price1 < Lower_BandS) and (condition_BandRevUp)) then high else Double.NaN; def YLOB = if coloredCandlesOn and ((price1 > Upper_BandS) and (condition_BandRevDn)) then low else Double.NaN; def YLOS = if coloredCandlesOn and ((price1 < Lower_BandS) and (condition_BandRevUp)) then low else Double.NaN; #extend midline of yellow candle plot YCOB = if !IsNaN(YHOB) then hl2 else Double.NaN; YCOB.SetPaintingStrategy(PaintingStrategy.HORIZONTAL); YCOB.SetDefaultColor(Color.GREEN); def YHextOB = if IsNaN(YCOB) then YHextOB[1] else YCOB; plot YHextlineOB = YHextOB; YHextlineOB.SetPaintingStrategy(PaintingStrategy.HORIZONTAL); YHextlineOB.SetDefaultColor(Color.ORANGE); YHextlineOB.SetLineWeight(2); plot YCOS = if !IsNaN(YHOS) then hl2 else Double.NaN; YCOS.SetPaintingStrategy(PaintingStrategy.HORIZONTAL); YCOS.SetDefaultColor(Color.GREEN); def YHextOS = if IsNaN(YCOS) then YHextOS[1] else YCOS; plot YHextlineOS = YHextOS; YHextlineOS.SetPaintingStrategy(PaintingStrategy.HORIZONTAL); YHextlineOS.SetDefaultColor(Color.LIGHT_GREEN); YHextlineOS.SetLineWeight(2); def YC = coloredCandlesOn and priceColor == 1 and price1 > Upper_BandS and condition_BandRevDn; def HH = Highest(high[1], BarsUsedForRange); def LL = Lowest(low[1], BarsUsedForRange); def maxH = Highest(HH, BarsRequiredToRemainInRange); def maxL = Lowest(LL, BarsRequiredToRemainInRange); def HHn = if maxH == maxH[1] or maxL == maxL then maxH else HHn[1]; def LLn = if maxH == maxH[1] or maxL == maxL then maxL else LLn[1]; def Bh = if high <= HHn and HHn == HHn[1] then HHn else Double.NaN; def Bl = if low >= LLn and LLn == LLn[1] then LLn else Double.NaN; def CountH = if IsNaN(Bh) or IsNaN(Bl) then 2 else CountH[1] + 1; def CountL = if IsNaN(Bh) or IsNaN(Bl) then 2 else CountL[1] + 1; def ExpH = if BarNumber() == 1 then Double.NaN else if CountH[-BarsRequiredToRemainInRange] >= BarsRequiredToRemainInRange then HHn[-BarsRequiredToRemainInRange] else if high <= ExpH[1] then ExpH[1] else Double.NaN; def ExpL = if BarNumber() == 1 then Double.NaN else if CountL[-BarsRequiredToRemainInRange] >= BarsRequiredToRemainInRange then LLn[-BarsRequiredToRemainInRange] else if low >= ExpL[1] then ExpL[1] else Double.NaN; def BoxHigh = if ((DOWN_OB) or (Upper_BandS crosses above Upper_BandK2) or (condition_BandRevDn) and (high > high[1]) and ((price > Upper_BandK2) or (price > Upper_BandS))) then Highest(ExpH) else Double.NaN; def BoxLow = if (DOWN_OB) or ((Upper_BandS crosses above Upper_BandK2)) then Lowest(low) else Double.NaN; def BoxHigh2 = if ((UP_OS) or ((Lower_BandS crosses below Lower_BandK2))) then Highest(ExpH) else Double.NaN; def BH2 = if !IsNaN(BoxHigh2) then high else Double.NaN; def BH2ext = if IsNaN(BH2) then BH2ext[1] else BH2; def BH2extline = BH2ext; plot H_BH2extline = Lowest(BH2extline, 1); H_BH2extline.SetDefaultColor(Color.GREEN); def BoxLow2 = if ((UP_OS) or (Lower_BandS crosses below Lower_BandK2) or (condition_BandRevUp) and (low < low[1]) and ((price < Lower_BandK2) or (price < Lower_BandS))) or ((UP_OS[1]) and (low < low[1])) then Lowest(low) else Double.NaN; def BH1 = if !IsNaN(BoxHigh) then high else Double.NaN; def BH1ext = if IsNaN(BH1) then BH1ext[1] else BH1; def BH1extline = BH1ext; def BL1 = if !IsNaN(BoxLow) then low else Double.NaN; def BL1ext = if IsNaN(BL1) then BL1ext[1] else BL1; plot BL1extline = BL1ext; BL1extline.SetPaintingStrategy(PaintingStrategy.HORIZONTAL); BL1extline.SetDefaultColor(Color.RED); BL1extline.SetLineWeight(1); def BL2 = if !IsNaN(BoxLow2) then low else Double.NaN; def BL2ext = if IsNaN(BL2) then BL2ext[1] else BL2; plot BL2extline = BL2ext; BL2extline.SetPaintingStrategy(PaintingStrategy.HORIZONTAL); BL2extline.SetDefaultColor(Color.GREEN); BL2extline.SetLineWeight(1); plot H_BH1extline = Highest(BH1extline, 1); H_BH1extline.SetDefaultColor(Color.RED); plot L_BL1extline = Highest(BL1extline, 1); L_BL1extline.SetDefaultColor(Color.RED); plot L_BL2extline = Lowest(BL2extline, 1); L_BL2extline.SetDefaultColor(Color.GREEN); AddCloud(if !HideCloud then BH1extline else Double.NaN, BL1extline, Color.RED, Color.GRAY); AddCloud(if !HideCloud then BH2extline else Double.NaN, BL2extline, Color.GREEN, Color.GRAY); ############################################################ ##C3_MF_Line_v2 Created by Christopher84 03/06/2022 ############################################################ #Keltner Channel def BulgeLengthPrice2 = 20; def SqueezeLengthPrice2 = 20; def BulgeLengthPrice3 = 12; def SqueezeLengthPrice3 = 12; def IntermResistance = Highest(price, BulgeLengthPrice); def IntermSupport = Lowest(price, SqueezeLengthPrice); def NearTResistance = Highest(price, BulgeLengthPrice2); def NearTSupport = Lowest(price, SqueezeLengthPrice2); def NearTResistance1 = Highest(price, BulgeLengthPrice3); def NearTSupport1 = Lowest(price, SqueezeLengthPrice3); script WMA_Smooth { input price_WMA = hl2; plot smooth = (4 * price_WMA + 3 * price_WMA[1] + 2 * price_WMA[2] + price_WMA[3]) / 10; } script Phase_Accumulation { # This is Ehler's Phase Accumulation code. It has a full cycle delay. # However, it computes the correction factor to a very high degree. input price_WMA = hl2; rec Smooth; rec Detrender; rec Period; rec Q1; rec I1; rec I1p; rec Q1p; rec Phase1; rec Phase; rec DeltaPhase; rec DeltaPhase1; rec InstPeriod1; rec InstPeriod; def CorrectionFactor; if BarNumber() <= 5 then { Period = 0; Smooth = 0; Detrender = 0; CorrectionFactor = 0; Q1 = 0; I1 = 0; Q1p = 0; I1p = 0; Phase = 0; Phase1 = 0; DeltaPhase1 = 0; DeltaPhase = 0; InstPeriod = 0; InstPeriod1 = 0; } else { CorrectionFactor = 0.075 * Period[1] + 0.54; # Smooth and detrend my smoothed signal: Smooth = WMA_Smooth(price_WMA); Detrender = ( 0.0962 * Smooth + 0.5769 * Smooth[2] - 0.5769 * Smooth[4] - 0.0962 * Smooth[6] ) * CorrectionFactor; # Compute Quadrature and Phase of Detrended signal: Q1p = ( 0.0962 * Detrender + 0.5769 * Detrender[2] - 0.5769 * Detrender[4] - 0.0962 * Detrender[6] ) * CorrectionFactor; I1p = Detrender[3]; # Smooth out Quadrature and Phase: I1 = 0.15 * I1p + 0.85 * I1p[1]; Q1 = 0.15 * Q1p + 0.85 * Q1p[1]; # Determine Phase if I1 != 0 then { # Normally, ATAN gives results from -pi/2 to pi/2. # We need to map this to circular coordinates 0 to 2pi if Q1 >= 0 and I1 > 0 then { # Quarant 1 Phase1 = ATan(AbsValue(Q1 / I1)); } else if Q1 >= 0 and I1 < 0 then { # Quadrant 2 Phase1 = Double.Pi - ATan(AbsValue(Q1 / I1)); } else if Q1 < 0 and I1 < 0 then { # Quadrant 3 Phase1 = Double.Pi + ATan(AbsValue(Q1 / I1)); } else { # Quadrant 4 Phase1 = 2 * Double.Pi - ATan(AbsValue(Q1 / I1)); } } else if Q1 > 0 then { # I1 == 0, Q1 is positive Phase1 = Double.Pi / 2; } else if Q1 < 0 then { # I1 == 0, Q1 is negative Phase1 = 3 * Double.Pi / 2; } else { # I1 and Q1 == 0 Phase1 = 0; } # Convert phase to degrees Phase = Phase1 * 180 / Double.Pi; if Phase[1] < 90 and Phase > 270 then { # This occurs when there is a big jump from 360-0 DeltaPhase1 = 360 + Phase[1] - Phase; } else { DeltaPhase1 = Phase[1] - Phase; } # Limit our delta phases between 7 and 60 if DeltaPhase1 < 7 then { DeltaPhase = 7; } else if DeltaPhase1 > 60 then { DeltaPhase = 60; } else { DeltaPhase = DeltaPhase1; } # Determine Instantaneous period: InstPeriod1 = -1 * (fold i = 0 to 40 with v=0 do if v < 0 then v else if v > 360 then -i else v + GetValue(DeltaPhase, i, 41)); if InstPeriod1 <= 0 then { InstPeriod = InstPeriod[1]; } else { InstPeriod = InstPeriod1; } Period = 0.25 * InstPeriod + 0.75 * Period[1]; } plot DC = Period; } script Ehler_MAMA { input price_WMA = hl2; input FastLimit = 0.5; input SlowLimit = 0.05; rec Period; rec Period_raw; rec Period_cap; rec Period_lim; rec Smooth; rec Detrender; rec I1; rec Q1; rec jI; rec jQ; rec I2; rec Q2; rec I2_raw; rec Q2_raw; rec Phase; rec DeltaPhase; rec DeltaPhase_raw; rec alpha; rec alpha_raw; rec Re; rec Im; rec Re_raw; rec Im_raw; rec SmoothPeriod; rec vmama; rec vfama; def CorrectionFactor = Phase_Accumulation(price_WMA).CorrectionFactor; if BarNumber() <= 5 then { Smooth = 0; Detrender = 0; Period = 0; Period_raw = 0; Period_cap = 0; Period_lim = 0; I1 = 0; Q1 = 0; I2 = 0; Q2 = 0; jI = 0; jQ = 0; I2_raw = 0; Q2_raw = 0; Re = 0; Im = 0; Re_raw = 0; Im_raw = 0; SmoothPeriod = 0; Phase = 0; DeltaPhase = 0; DeltaPhase_raw = 0; alpha = 0; alpha_raw = 0; vmama = 0; vfama = 0; } else { # Smooth and detrend my smoothed signal: Smooth = WMA_Smooth(price_WMA); Detrender = ( 0.0962 * Smooth + 0.5769 * Smooth[2] - 0.5769 * Smooth[4] - 0.0962 * Smooth[6] ) * CorrectionFactor; Q1 = ( 0.0962 * Detrender + 0.5769 * Detrender[2] - 0.5769 * Detrender[4] - 0.0962 * Detrender[6] ) * CorrectionFactor; I1 = Detrender[3]; jI = ( 0.0962 * I1 + 0.5769 * I1[2] - 0.5769 * I1[4] - 0.0962 * I1[6] ) * CorrectionFactor; jQ = ( 0.0962 * Q1 + 0.5769 * Q1[2] - 0.5769 * Q1[4] - 0.0962 * Q1[6] ) * CorrectionFactor; # This is the complex conjugate I2_raw = I1 - jQ; Q2_raw = Q1 + jI; I2 = 0.2 * I2_raw + 0.8 * I2_raw[1]; Q2 = 0.2 * Q2_raw + 0.8 * Q2_raw[1]; Re_raw = I2 * I2[1] + Q2 * Q2[1]; Im_raw = I2 * Q2[1] - Q2 * I2[1]; Re = 0.2 * Re_raw + 0.8 * Re_raw[1]; Im = 0.2 * Im_raw + 0.8 * Im_raw[1]; # Compute the phase if Re != 0 and Im != 0 then { Period_raw = 2 * Double.Pi / ATan(Im / Re); } else { Period_raw = 0; } if Period_raw > 1.5 * Period_raw[1] then { Period_cap = 1.5 * Period_raw[1]; } else if Period_raw < 0.67 * Period_raw[1] { Period_cap = 0.67 * Period_raw[1]; } else { Period_cap = Period_raw; } if Period_cap < 6 then { Period_lim = 6; } else if Period_cap > 50 then { Period_lim = 50; } else { Period_lim = Period_cap; } Period = 0.2 * Period_lim + 0.8 * Period_lim[1]; SmoothPeriod = 0.33 * Period + 0.67 * SmoothPeriod[1]; if I1 != 0 then { Phase = ATan(Q1 / I1); } else if Q1 > 0 then { # Quadrant 1: Phase = Double.Pi / 2; } else if Q1 < 0 then { # Quadrant 4: Phase = -Double.Pi / 2; } else { # Both numerator and denominator are 0. Phase = 0; } DeltaPhase_raw = Phase[1] - Phase; if DeltaPhase_raw < 1 then { DeltaPhase = 1; } else { DeltaPhase = DeltaPhase_raw; } alpha_raw = FastLimit / DeltaPhase; if alpha_raw < SlowLimit then { alpha = SlowLimit; } else { alpha = alpha_raw; } vmama = alpha * price_WMA + (1 - alpha) * vmama[1]; vfama = 0.5 * alpha * vmama + (1 - 0.5 * alpha) * vfama[1]; } plot MAMA = vmama; plot FAMA = vfama; } def price2 = hl2; def FastLimit = 0.5; def SlowLimit = 0.05; def MAMA = Ehler_MAMA(price2, FastLimit, SlowLimit).MAMA; def FAMA = Ehler_MAMA(price2, FastLimit, SlowLimit).FAMA; def Crossing = Crosses((MAMA < FAMA), yes); def Crossing1 = Crosses((MAMA > FAMA), yes); def C3_Line_1 = if ((priceColor == 1) and (price1 > Upper_BandS) and (condition_BandRevDn)) then 1 else 0; def C3_Line_2 = if ((priceColor == -1) and (price1 < Lower_BandS) and (condition_BandRevUp)) then 1 else 0; def C3_Green = ((priceColor == 1)); def C3_red = ((priceColor == 1)); AddLabel(yes, Concat("MAMA", Concat("", if MAMA > FAMA then "" else "")), if MAMA > FAMA then Color.LIGHT_GREEN else Color.LIGHT_RED); def MF_UP = FAMA < MAMA; def MF_DN = FAMA > MAMA; def priceColor10 = if MF_UP then 1 else if MF_DN then -1 else priceColor10[1]; ################################### ##Consensus Level & Squeeze Label ################################### def MomentumUP = Consensus_Level[1] < Consensus_Level; def MomentumDOWN = Consensus_Level[1] > Consensus_Level; def conditionOB = (Consensus_Level >= 12) and (Consensus_Line >= 4); def conditionOS = (Consensus_Level <= -12) and (Consensus_Line <= -3); ################################### ##Big4 Strategy ################################### def cond_UP = cond1_UP + cond2_UP + cond3_UP + cond4_UP; def cond_DN = cond1_DN + cond2_DN + cond3_DN + cond4_DN; def direction = if cond_UP >= Strategy_Confirmation_Factor and (!Strategy_FilterWithTMO or cond5_UP) then 1 else if cond_DN <= -Strategy_Confirmation_Factor and (!Strategy_FilterWithTMO or cond5_DN) then -1 else if !Strategy_HoldTrend and direction[1] == 1 and cond_UP < Strategy_Confirmation_Factor and cond_DN > -Strategy_Confirmation_Factor then 0 else if !Strategy_HoldTrend and direction[1] == -1 and cond_DN > -Strategy_Confirmation_Factor and cond_UP < Strategy_Confirmation_Factor then 0 else direction[1]; def direction2 = if cond_UP >= Strategy_Confirmation_Factor and (!Strategy_FilterWithTMO_arrows or cond5_UP) then 1 else if cond_DN <= -Strategy_Confirmation_Factor and (!Strategy_FilterWithTMO_arrows or cond5_DN) then -1 else if !Strategy_HoldTrend and direction2[1] == 1 and cond_UP < Strategy_Confirmation_Factor and cond_DN > -Strategy_Confirmation_Factor then 0 else if !Strategy_HoldTrend and direction2[1] == -1 and cond_DN > -Strategy_Confirmation_Factor and cond_UP < Strategy_Confirmation_Factor then 0 else direction2[1]; #Spark1 plot AvgExp8 = ExpAverage(price[-displace], length8); def UPD = AvgExp8[1] < AvgExp8; AvgExp8.SetStyle(Curve.SHORT_DASH); AvgExp8.SetDefaultColor(CreateColor(255, 128, 0)); #Orange plot AvgExp9 = ExpAverage(price[-displace], length9); def UPW = AvgExp9[1] < AvgExp9; AvgExp9.SetStyle(Curve.SHORT_DASH); AvgExp9.SetDefaultColor(CreateColor(237, 106, 0)); #Orange ################################### #SPARK# ################################### def Below = AvgExp8 < AvgExp9; def Spark = UPD + UPW + Below; def UPEMA = AvgExp8[1] < AvgExp8; def DOWNEMA = AvgExp8[1] > AvgExp8; def BigUP = direction == 1; def BigDN = direction == -1; def BigNa = direction == 0; AvgExp8.AssignValueColor(if UPEMA then Color.LIGHT_GREEN else if DOWNEMA then Color.RED else Color.YELLOW); def UPEMA2 = AvgExp9[1] < AvgExp9; def DOWNEMA2 = AvgExp9[1] > AvgExp9; def UP8 = UPEMA and UPEMA2; def DOWN8 = DOWNEMA and DOWNEMA2; def priceColor8 = if UP8 then 1 else if DOWN8 then -1 else 0; def UP11 = UPEMA; def DOWN11 = DOWNEMA; def priceColor11 = if UP11 then 1 else if DOWN11 then -1 else 0; def UP12 = UPEMA2; def DOWN12 = DOWNEMA2; def priceColor12 = if UP12 then 1 else if DOWN12 then -1 else 0; def UpCalc = (priceColor == 1) + (priceColor == 1) + (priceColor8 == 1) + (priceColor10 == 1); def StrongUpCalc = (priceColor == 1) + (priceColor == 1) + (priceColor10 == 1); def CandleColor = if (priceColor == 1) and (priceColor12 == 1) and (Spark >= 2) then 1 else if (priceColor == -1) and (Spark < 1) then -1 else 0; def SparkUP = (Spark == 3) and (CandleColor == 1); def SparkDN = (Spark == 0) and (CandleColor == -1); def SparkUP1 = (Spark == 3) and (CandleColor == 1); def SparkDN1 = (Spark == 0) and (CandleColor == -1); def hide_SparkUP = if SparkUP1 and (SparkUP1[1] or SparkUP1[2] or SparkUP1[3] or SparkUP1[4] or SparkUP1[5]) then 0 else 1; def hide_SparkDN = if SparkDN1 and (SparkDN1[1] or SparkDN1[2] or SparkDN1[3] or SparkDN1[4] or SparkDN1[5]) then 0 else 1; def BigUPs = direction2 == 1 and direction2[1] < 1; def BigDNs = direction2 == -1 and direction2[1] > -1; def hide_BigUPs = if BigUPs and (BigUPs[1] or BigUPs[2] or BigUPs[3]) then 1 else 0; def hide_BigDNs = if BigDNs and (BigDNs[1] or BigDNs[2] or BigDNs[3]) then 1 else 0; def signal_up_price = if bigups then round(close,2) else signal_up_price[1]; def signal_dn_price = if bigdns then round(close,2) else signal_dn_price[1]; def sigmath = absvalue(signal_up_price - signal_up_price[1]); def sig2math = absvalue(signal_up_price - signal_dn_price[1]); def sig3math = absvalue(signal_dn_price - signal_dn_price[1]); def agperiod1 = GetAggregationPeriod(); def timeframe = if agperiod1 <= aggregationperiod.DAY then aggregationperiod.DAY else agperiod1; def Vol = volume(period = timeframe); def at_High = high(period = timeframe); def at_Open = open(period = timeframe); def at_Close = close(period = timeframe); def at_Low = low(period = timeframe); def Vol1 = volume(period = timeframe); def at_High1 = high(period = timeframe); def at_Open1 = open(period = timeframe); def at_Close1 = close(period = timeframe); def at_Low1 = low(period = timeframe); def Buy_Volume = RoundUp(Vol * (at_Close - at_Low) / (at_High - at_Low)); def Buy_percent = RoundUp((Buy_Volume / Vol) * 100); def Sell_Volume = RoundDown(Vol1 * (at_High1 - at_Close1) / (at_High1 - at_Low1)); def Sell_percent = RoundUp((Sell_Volume / Vol1) * 100); plot avg1 = ExpAverage(close(period = agperiod1), length8); def height = avg1 - avg1[length8]; avg1.SetStyle(Curve.SHORT_DASH); avg1.SetLineWeight(1); def UP1 = avg1[1] < avg1; def DOWN1 = avg1[1] > avg1; Avg1.AssignValueColor(if UP1 then Color.LIGHT_GREEN else if DOWN1 then Color.RED else Color.gray); plot avg2 = ExpAverage(close(period = agperiod1), length8); def height2 = avg2 - avg2[length10]; avg2.SetStyle(Curve.SHORT_DASH); avg2.SetLineWeight(1); def UP2 = avg2[1] < avg2; def DOWN2 = avg2[1] > avg2; Avg2.AssignValueColor(if UP2 then Color.LIGHT_GREEN else if DOWN2 then Color.RED else Color.gray); # --- TRIPLE EXHAUSTION --- def over_bought_3x = 80; def over_sold_3x = 20; def KPeriod_3x = 10; def DPeriod_3x = 10; def priceH1 = high(period = agperiod1); def priceL1 = low(period = agperiod1); def priceC1 = close(period = agperiod1); def priceO1 = close(period = agperiod1); def priceH_3x = high; def priceL_3x = low; def priceC_3x = close; # --- TRIPLE EXHAUSTION INDICATORS - StochasticSlow / MACD / MACD StDev /DMI+/- def bn = barnumber(); def SlowK_3x = reference StochasticFull(over_bought_3x, over_sold_3x, KPeriod_3x, DPeriod_3x, priceH_3x, priceL_3x, priceC_3x, 3, averagetype).FullK; def MACD_3x = reference MACD()."Value"; def priceMean_3x = Average(MACD_3x, length_3x); def MACD_stdev_3x = (MACD_3x - priceMean_3x) / StDev(MACD_3x, length_3x); def dPlus_3x = reference DMI()."DI+"; def dMinus_3x = reference DMI()."DI-"; def sellerRegular = SlowK_3x < 20 and MACD_stdev_3x < -1 and dPlus_3x < 15; def sellerExtreme = SlowK_3x < 20 and MACD_stdev_3x < -2 and dPlus_3x < 15; def buyerRegular = SlowK_3x > 80 and MACD_stdev_3x > 1 and dMinus_3x < 15; def buyerExtreme = SlowK_3x > 80 and MACD_stdev_3x > 2 and dMinus_3x < 15; #Arrows/Triggers def RegularBuy = if sellerRegular[1] and !sellerRegular then 1 else 0; def RegularBuy_bn = if RegularBuy then bn else RegularBuy_bn[1]; def ExtremeBuy = if sellerExtreme[1] and !sellerExtreme then 1 else 0; def ExtremeBuy_bn = if ExtremeBuy then bn else ExtremeBuy_bn[1]; def RegularSell = if buyerRegular[1] and !buyerRegular then 1 else 0; def RegularSell_bn = if RegularSell then bn else RegularSell_bn[1]; def ExtremeSell = if buyerExtreme[1] and !buyerExtreme then 1 else 0; def ExtremeSell_bn = if ExtremeSell then bn else ExtremeSell_bn[1]; def Condition1UP = avg1 > avg2; def Condition1DN = avg1 < avg2; def Condition2UP = Buy_percent > 50; def Condition2DN = Buy_percent < 50; def BullUP = Condition1UP + Condition2UP; def BearDN = Condition1DN + Condition2DN; def Bull_Bear = if Condition1UP==1 and Condition2UP == 1 then 1 else if Condition1DN == 1 and Condition2DN == 1 then -1 else 0; def Condition3UP = if buyerRegular then 1 else 0; def Condition3DN = if sellerRegular then 1 else 0; def Condition4UP = if buyerExtreme then 1 else 0; def Condition4DN = if sellerExtreme then 1 else 0; def priceColor1 = if ((avg1[1]<avg1) and (avg2[1]<avg2)) then 1 else if((avg1[1]>avg1) and (avg2[1]>avg2)) then -1 else priceColor[1]; def pd = 22; def bbl = 20; def lb = 50; def ph = 0.85; def pl = 1.01; # Downtrend Criterias def ltLB = 40; def mtLB = 14; def str = 3; def AtrMult_Blst = 1.0; def nATR_Blst = 4; def AvgType_Blst = AverageType.HULL; def trig_Blst = 20; def pd_Blst = 22; def bbl_Blst = 20; def mult = 50; def mult_Blst = 2.0; def lb_Blst = 50; def ph_Blst = 0.85; def pl_Blst = 1.01; def ATR = MovingAverage(AvgType, TrueRange(high, close, low), nATR_Blst); def UP_B = HL2 + (AtrMult * ATR); def DN = HL2 + (-AtrMult * ATR); def ST = if close < ST[1] then UP_B else DN; def SuperTrend = ST; def val1 = AbsValue(close - open); def range = high - low; def blastOffVal = (val1 / range) * 100; def trigger = trig; def alert1 = blastOffVal < trig; def col = blastOffVal < trig; def blast_candle = blastOffVal < trig; # Downtrend Criterias def ltLB_Blst = 40; def mtLB_Blst = 14; def wvf = ((highest(close, pd) - low) / (highest(close, pd))) * 100; def sDev = mult * stdev(wvf, bbl); def midLine1 = SimpleMovingAvg(wvf, bbl); def lowerBand1 = midLine1 - sDev; def upperBand1 = midLinE1 + sDev; def rangeHigh = (highest(wvf, lb)) * ph; # Filtered Bar Criteria def upRange = low > low[1] and close > high[1]; def upRange_Aggr = close > close[1] and close > open[1]; def filtered = ((wvf[1] >= upperBand1[1] or wvf[1] >= rangeHigh[1]) and (wvf<upperBand1 and wvf<rangeHigh)); def filtered_Aggr = (wvf[1] >= upperBand1[1] or wvf[1] >= rangeHigh[1]); # Alerts Criteria 1 def alert4 = upRange_Aggr and close > close[str] and (close < close[ltLB] or close < close[mtLB]) and filtered_Aggr; def BulgeLengthV = 20; def SqueezeLengthV = 20; def BulgeLengthV2 = 20; def SqueezeLengthV2 = 20; ################################### ##Candle Color ################################### AssignPriceColor(if Strategy_ColoredCandlesOn then if alert4 and alert4[1] then Color.magenta else if alert4 then Color.cyan else if color_OBOS and (C3_LINE_1 OR C3_LINE_2) then Color.YELLOW else if Color_3x and buyerRegular then Color.green else if Color_3xt and buyerExtreme then Color.green else if direction == 1 then Color.LIGHT_GREEN else if Color_blst and close < ST and blastOffVal < trig then Color.white else if Color_3x and sellerRegular then Color.dark_red else if Color_3xt and sellerExtreme then Color.Dark_red else if direction == -1 then Color.RED else Color.GRAY else Color.CURRENT); ################################### ##Plots ################################### plot TS_UP = if show_ts_signals and upsignal then 1 else 0; TS_UP.SetPaintingStrategy(PaintingStrategy.BOOLEAN_ARROW_UP); TS_UP.AssignValueColor(color.cyan); plot TS_DN = if show_ts_signals and downsignal then 1 else 0; TS_DN.SetPaintingStrategy(PaintingStrategy.BOOLEAN_ARROW_DOWN); TS_DN.AssignValueColor(Color.cyan); plot SparkUP_1 = (SparkUP1 and hide_SparkUP); SparkUP_1.SetPaintingStrategy(PaintingStrategy.BOOLEAN_ARROW_UP); SparkUP_1.AssignValueColor(Color.green); plot SparkDN_1 = (SparkDN1 and hide_SparkDN); SparkDN_1.SetPaintingStrategy(PaintingStrategy.BOOLEAN_ARROW_DOWN); SparkDN_1.AssignValueColor(Color.Light_red); plot signal_up = (direction2 == 1 and direction2[1] < 1); signal_up.SetPaintingStrategy(PaintingStrategy.BOOLEAN_ARROW_UP); signal_up.AssignValueColor(if(direction2 == 1 and direction2[1] < 1)then color.white else color.gray); signal_up.Hide(); signal_up.HideBubble(); signal_up.HideTitle(); plot signal_dn = (direction2 == -1 and direction2[1] > -1); signal_dn.SetPaintingStrategy(PaintingStrategy.BOOLEAN_ARROW_DOWN); signal_dn.AssignValueColor(if(direction2 == -1 and direction2[1] > -1) then color.white else color.gray); signal_dn.Hide(); signal_dn.HideBubble(); signal_dn.HideTitle(); ################################### ##Alerts ################################### Alert(signal_up[1], "Buy", Alert.BAR, Sound.DING); Alert(signal_dn[1], "Sell", Alert.BAR, Sound.DING); ################################### ##Labels ################################### def Buy = UP_OS; def Sell = DOWN_OB; def conditionLTB = (conditionK2UP and (Consensus_Level < 0)); def conditionLTS = (conditionK3DN and (Consensus_Level > 0)); def conditionBO = ((Upper_BandS[1] < Upper_BandS)) and ((Lower_BandS[1] < Lower_BandS)) and ((Upper_BandK[1] < Upper_BandK)) and ((Lower_BandK[1] < Lower_BandK)); def conditionBD = ((Upper_BandS[1] > Upper_BandS)) and ((Lower_BandS[1] > Lower_BandS)) and ((Upper_BandK[1] > Upper_BandK)) and ((Lower_BandK[1] > Lower_BandK)); # --- C3 LABELS --- AddLabel(yes, if conditionLTB then "BULL: Look to Buy" else if conditionLTS then "BEAR: Look to Sell" else if conditionK2UP then "TREND: BULL" else if conditionK3DN then "TREND: BEAR" else "TREND: CONSOLIDATION", if conditionLTB then Color.GREEN else if conditionLTS then Color.RED else if conditionK2UP then Color.LIGHT_GREEN else if conditionK3DN then Color.LIGHT_RED else Color.GRAY); AddLabel(yes, if conditionBD then "BREAKDOWN" else if conditionBO then "BREAKOUT" else "NO BREAK", if conditionBD then Color.RED else if conditionBO then Color.GREEN else Color.GRAY); def Spark_2_label = yes; def Spark_3_label = yes; def Spark_4_label = yes; #Spark 1 AddLabel(showLabels, if (Spark == 3) then "SPARK: " + Round(Spark, 1) else if (Spark == 0) then "SPARK: " + Round(Spark, 1) else "SPARK: " + Round(Spark, 1), if (Spark == 3) then Color.YELLOW else if (Spark == 2) then Color.GREEN else if (Spark == 0) then Color.RED else Color.GRAY); #--- END --- AddLabel(showlabels, if Condition1UP==1 and Condition2UP == 1 and (Condition3UP == 1 or Condition4UP == 1) then "**CALLS ONLY!**" else if Condition1UP == 1 and Condition2UP == 1 then "Very Bullish" else if direction == 1 then "Bullish" else if Condition1DN == 1 and Condition2DN == 1 and (Condition3DN == 1 or Condition4DN == 1) then "**PUTS ONLY!**" else if Condition1DN == 1 and Condition2DN == 1 then "Very Bearish" else if direction == -1 then "Bearish" else if ((avg[1] > avg) and (avg > avg2) and (Buy_percent > 50)) then "Bullish Retracement" else if ((avg[1] < avg) and (avg < avg2) and (Buy_percent < 50)) then "Bearish Retracement" else "CHOP", if Condition1UP == 1 and Condition2UP == 1 and (Condition3UP == 1 or Condition4UP == 1) then Color.cyan else if Condition1DN == 1 and Condition2DN == 1 and (Condition3DN == 1 or Condition4DN == 1) then Color.Magenta else if Condition1UP == 1 and Condition2UP == 1 then Color.GREEN else if direction == 1 then Color.green else if Condition1DN == 1 and Condition2DN == 1 then Color.RED else if direction == -1 then Color.red else Color.orange); AddLabel(yes, if MomentumUP then "Consensus Increasing = " + Round(Consensus_Level, 1) else if MomentumUP or MomentumDOWN and conditionOB then "Consensus OVERBOUGHT = " + Round(Consensus_Level, 1) else if MomentumDOWN then "Consensus Decreasing = " + Round(Consensus_Level, 1) else if MomentumUP or MomentumDOWN and conditionOS then "Consensus OVERSOLD = " + Round(Consensus_Level, 1) else "Consensus = " + Round(Consensus_Level, 1), if conditionOB then Color.dark_RED else if conditionOS then Color.dark_GREEN else Color.GRAY); AddLabel(squeeze_Alert, "SQUEEZE ALERT", if Squeeze_Alert then Color.YELLOW else Color.GRAY); AddVerticalLine(showverticallineday and( GetDay() <> GetDay()[1]), "", Color.dark_gray, Curve.SHORT_DASH); #
hmmm seems like a chart settings issue... I suppose you have the height adjustment set to auto?
First of all, thanks a bunch for the work you have done and that you are willing to share this!! Would you be able to give links to your most recent setup? I have had quite a few versions and not sure what the latest combination is. I think several studies have been combined and some of mine may be outdated. Thanks again!!
I found that the most simple way using a chart indicator, to avoid those "fake" bounces it is to add a slow MACD to be used in conjunction with the Emad. The slow MACD (Wilders smoothing 21+55+13) will filter out most of those little pops, although if you get a sudden real bounce or a reversal and wait for the slow Macd crossover confirmation you may get a late entry.
The only way to get mobile alerts is to:
Have the red and green dots been removed from this version? When a verion is updated, like the one in this post, is it also updated on pg. 1?Current Chart Style - http://tos.mx/88U2YzQ
EMAD Range (newest variant "V1000") - http://tos.mx/5jmDs9c
Code:#EMAD Range by @ Christopher84 #EMAD V1000 - added arrow conditions - histogram - and color conditions HODL #DECLARATIONS declare lower; #USER INPUTS input showHLLH = no; input showHowToLabel = yes; input ShowColorCodeLabel = no; input showtestlabels = no; input showEMACloud = yes; input showBubbles = no; input showTripleExh = yes; input showehlers = no; input showMAD = no; input showverticalline = yes; input bandLength = 100; input bandLength2 = 100; input ELlength = 34; Input LengtH_MAD = 4; input fastLength = 10; input slowLength = 35; input lengthBAD = 3; input smoothLength = 12; input smoothLength2 = 14; input ATRPeriod = 5; input ATRFactor = 2.0; input length_3x = 1000; input priceType = close; input emadLineWeight = 2; input averageType = AverageType.WILDERS; input averageType_Sq = AverageType.SIMPLE; input firstTrade_Sq = {default long, short}; input trailType = {default modified, unmodified}; input firstTrade = {default long, short}; input filterBounceArrows = 1; input filter_3x = 50; input Control_3x = 3; input crossabovebelowzero = 20; input bandlengthbottom2 = 3; input Lookback = 20; input cloudlinelook = 20; input LHHL_Lookback = 1; input Steplookback = 10; input filterZeroline = 20; input topbanddownlookback = 1; input bottombanduplookback = 1; input SqueezeLook = 5; input alert4lookback = 21; input PreviousStepsDown = 2; input PreviousStepsUp = 2; input alert4control = 2; input tradeDaytimeOnly = yes; #hint tradeDaytimeOnly: (IntraDay Only) Only perform trades during hours stated input OpenTime = 0730; #hint OpenTime: Opening time of market input CloseTime = 1800; #hint CloseTime: Closing time of market def bn = barnumber(); def Begin = SecondsFromTime(OpenTime); def End = SecondsTillTime(CloseTime); def isIntraDay = if GetAggregationPeriod() > 14400000 or GetAggregationPeriod() == 0 then 0 else 1; def MarketOpen = if !tradeDaytimeOnly or !isIntraDay then 1 else if tradeDaytimeOnly and isIntraDay and Begin > 0 and End > 0 then 1 else 0; #GLOBAL COLOR DEFINITIONS DefineGlobalColor("Green", CreateColor(0, 155, 0)); DefineGlobalColor("Red", CreateColor(225, 105, 105)); DefineGlobalColor("Gray", CreateColor(192, 192, 192)); DefineGlobalColor("Yellow", CreateColor(231, 190, 0)); ## UPPER EMAD LINE def fastExpAvg = ExpAverage(priceType, fastLength); def slowExpAvg = ExpAverage(priceType, slowLength); def EMAD = (priceType - fastExpAvg); def EMAD2 = (priceType - slowExpAvg); def EMADAvg = (EMAD + EMAD2) / 2; def upperEMADLine = ExpAverage(EMADAvg, smoothLength); ## LOWER EMAD LINE def emadOpen = (upperEMADLine + upperEMADLine[1]) / 2; def emadHigh = Max(upperEMADLine, upperEMADLine[1]); def emadLow = Min(upperEMADLine, upperEMADLine[1]); def emadClose = upperEMADLine; def bottom = Min(emadClose[1], emadLow); def tr = TrueRange(emadHigh, emadClose, emadLow); def ptr = tr / (bottom + tr / 2); def APTR = MovingAverage(averageType, ptr, smoothLength2); def upperBand = emadClose[1] + (APTR * emadOpen); def lowerBand = emadClose[1] - (APTR * emadOpen); def lowerEMADLine = (upperBand + lowerBand) / 2; ## TOP AND BOTTOM BANDS def zeroLineData = if IsNaN(close) then Double.NaN else 0; def EMADSUp = upperEMADLine > zeroLineData; def EMADSDown = upperEMADLine < zeroLineData; def EMADdown = (lowerEMADLine > upperEMADLine); def EMADup = (upperEMADLine >= lowerEMADLine); def topBand = Highest(lowerEMADLine, bandLength); def bottomBand = Lowest(lowerEMADLine, bandLength); def zerolinedatacondition = if (zerolinedata > topBand) then topBand else if (zerolinedata < bottomBand) then bottomBand else 0; ## Master def masteremadline = (upperEMADLine + lowerEMADLine) / 2; ## BAND DIRECTION (USED ONLY FOR COLORING - NOT USED FOR PLOTS) def topBandStepDown = if topBand < topBand[1] then 1 else 0; def topBandStepUp = if topBand > topBand[1] then 1 else 0; def bottomBandStepDown = if bottomBand < bottomBand[1] then 1 else 0; def bottomBandStepUp = if bottomBand > bottomBand[1] then 1 else 0; def bothBandsDown = bottomBandStepDown and topBandStepDown; def bothBandsUp = bottomBandStepUp and topBandStepUp; def bullBias = (bottomBand > zeroLineData); def bearBias = (topBand < zeroLineData); ## BUBBLE CALCULATIONS (USED ONLY FOR BUBBLES) def midBand = (upperBand + lowerBand) / 2; def crossesUp = if (midBand[1] > upperEMADLine[1])and(midBand < upperEMADLine) then 1 else 0; def crossesDown = if (upperEMADLine[1] > midBand[1])and(upperEMADLine < midBand) then 1 else 0; def valueUp = if crossesUp then midBand else 0; def valueDown = if crossesDown then midBand else 0; def crossesUpline = if (valueUp - bottomBand) == 0 then 1 else 0; def crossesDownline = if (valueDown - topBand) == 0 then 1 else 0; def crossesUpline_filter = if crossesUpline and (crossesUpline[1] or crossesUpline[2] or crossesUpline[3] or crossesUpline[4])then 0 else 1; def crossesDownline_filter = if crossesDownline and (crossesDownline[1] or crossesDownline[2] or crossesDownline[3] or crossesDownline[4])then 0 else 1; def crossesUpZeroline = if (valueUp) == 0 then 1 else 0; def crossesDownZeroline = if (valueDown) == 0 then 1 else 0; def crossesUpBottomlinebn = if crossesUpline and !crossesUpline[1] then bn else crossesUpBottomlinebn[1]; def crossesDownToplinebn = if crossesDownline and !crossesDownline[1] then bn else crossesDownToplinebn[1]; def crossuplinewithin = if crossesUpBottomlinebn < bn then bn - crossesUpBottomlinebn else crossuplinewithin[1]; def crossdownlinewithin = if crossesDownToplinebn < bn then bn - crossesDownToplinebn else crossdownlinewithin[1]; def crosslinefirst = if crossuplinewithin < crossdownlinewithin then 1 else 0; def crosslinelogic = crossesUpBottomlinebn > crossesDownToplinebn; def HL = crossesUpline == 0 and crossesDownline == 0 and upperEMADLine crosses above lowerEMADLine; #Normal HL LH condition def LH = crossesDownline == 0 and upperEMADLine crosses below lowerEMADLine; #Normal HL LH condition def bounceUpOnce = crossesUpline <> crossesUpline[1]; #XUpBtm happened previous bar or on current bar def bounceDnOnce = crossesDownline <> crossesDownline[1]; def trackCrUp = if bounceUpOnce then 0 else if HL then 1 else trackCrUp[1]; def trackCrDn = if bounceDnOnce then 0 else if LH then 1 else trackCrDn[1]; ## SECOND HL AND LH def HLalready = if trackCrUp and !trackCrUp[1] then 1 else 0; def LHalready = if trackCrDn and !trackCrDn[1] then 1 else 0; def HL2 = HLalready == 0 and upperEMADLine crosses above lowerEMADLine; def LH2 = LHalready == 0 and upperEMADLine crosses below lowerEMADLine; def crossedUpOnce = HLalready <> HLalready[1]; def crossedDnOnce = LHalready <> LHalready[1]; def trackCrUp2 = if crossedUpOnce then 0 else if HL2 then 1 else trackCrUp2[1]; def trackCrDn2 = if crossedDnOnce then 0 else if LH2 then 1 else trackCrDn2[1]; ##################################################### ## ## ##################################################### def HiLo = Min(high - low, 1.5 * Average(high - low, ATRPeriod)); def HRef = if low <= high[1] then high - close[1] else (high - close[1]) - 0.5 * (low - high[1]); def LRef = if high >= low[1] then close[1] - low else (close[1] - low) - 0.5 * (low[1] - high); def trueRange_Sq; switch (trailType) { case modified: trueRange_Sq = Max(HiLo, Max(HRef, LRef)); case unmodified: trueRange_Sq = TrueRange(high, close, low); } def loss_Sq = ATRFactor * MovingAverage(averageType_Sq, trueRange_Sq, ATRPeriod); def state_Sq = {default init, long, short}; def trail_Sq; switch (state_Sq[1]) { case init: if (!IsNaN(loss_Sq)) { switch (firstTrade) { case long: state_Sq = state_Sq.long; trail_Sq = close - loss_Sq; case short: state_Sq = state_Sq.short; trail_Sq = close + loss_Sq; } } else { state_Sq = state_Sq.init; trail_Sq = Double.NaN; } case long: if (close > trail_Sq[1]) { state_Sq = state_Sq.long; trail_Sq = Max(trail_Sq[1], close - loss_Sq); } else { state_Sq = state_Sq.short; trail_Sq = close + loss_Sq; } case short: if (close < trail_Sq[1]) { state_Sq = state_Sq.short; trail_Sq = Min(trail_Sq[1], close + loss_Sq); } else { state_Sq = state_Sq.long; trail_Sq = close - loss_Sq; } } def TrailingStop_Sq = trail_Sq; def H = Highest(TrailingStop_Sq, 12); def L = Lowest(TrailingStop_Sq, 12); def BulgeLengthPrice = 100; def SqueezeLengthPrice = 100; def BandwidthC3 = (H - L); def IntermResistance2 = Highest(BandwidthC3, BulgeLengthPrice); def IntermSupport2 = Lowest(BandwidthC3, SqueezeLengthPrice); def sqzTrigger = BandwidthC3 <= IntermSupport2; def sqzLevel = if !sqzTrigger[1] and sqzTrigger then hl2 else if !sqzTrigger then Double.NaN else sqzLevel[1]; def Squeeze_Alert_1 = if sqzLevel then (upperEMADLine + lowerEMADLine) / 2 else (upperEMADLine + lowerEMADLine) / 2 ; ##################################################### ## ## ##################################################### def over_bought_3x = 80; def over_sold_3x = 20; def KPeriod_3x = 10; def DPeriod_3x = 10; def priceH1 = high; def priceL1 = low; def priceC1 = close; def priceO1 = close; def priceH_3x = high; def priceL_3x = low; def priceC_3x = close; def SlowK_3x = reference StochasticFull(over_bought_3x, over_sold_3x, KPeriod_3x, DPeriod_3x, priceH_3x, priceL_3x, priceC_3x, 3, if (averageType == 1) then AverageType.SIMPLE else AverageType.EXPONENTIAL).FullK; def MACD_3x = reference MACD()."Value"; def priceMean_3x = Average(MACD_3x, length_3x); def MACD_stdev_3x = (MACD_3x - priceMean_3x) / StDev(MACD_3x, length_3x); def dPlus_3x = reference DMI()."DI+"; def dMinus_3x = reference DMI()."DI-"; def sellerRegular = SlowK_3x < 20 and MACD_stdev_3x < -1 and dPlus_3x < 15; def sellerExtreme = SlowK_3x < 20 and MACD_stdev_3x < -2 and dPlus_3x < 15; def buyerRegular = SlowK_3x > 80 and MACD_stdev_3x > 1 and dMinus_3x < 15; def buyerExtreme = SlowK_3x > 80 and MACD_stdev_3x > 2 and dMinus_3x < 15; def ExtremeBuy1 = if sellerExtreme[1] and !sellerExtreme then 1 else 0; def ExtremeSell1 = if buyerExtreme[1] and !buyerExtreme then 1 else 0; def RegularSell1 = if buyerRegular[1] and !buyerRegular then 1 else 0; def RegularBuy1= if sellerRegular[1] and !sellerRegular then 1 else 0; ##################################################### ## ## ##################################################### def priceE = (emadhigh + emadlow) / 2; def coeff = ELlength * priceE * priceE - 2 * priceE * sum(priceE, ELlength)[1] + sum(priceE * priceE, ELlength)[1]; def Ehlers = sum(coeff * priceE, ELlength) / sum(coeff, ELlength); ##################################################### ## ## ##################################################### def dataA = masterEMADLine; def dataA1 = fold aD = 0 to LengtH_MAD with k = 0 do k + dataA[aD]; def MAEMAD = dataA1 / LengtH_MAD; def MAD = MAEMAD; def ElCrossDN = ehlers crosses above masterEMADline; def ElCrossUP = ehlers crosses below masterEMADline; def bullBias2 = (emadsup); def bearBias2 = (emadsdown); def MADehlers = (MAD - Ehlers)/2; def Madebad = madehlers + ehlers; def madebadavg = average(madebad, lengthBAD); def crossmadeup = madebad > madebad[1]; def crossmadedn = madebad < madebad[1]; def crossmade2up = if (madebad < masterEMADLine) and crossmadeup and (bullBias2 > 0) then 1 else 0; def crossmade2dn = if (madebad > masterEMADLine) and crossmadedn and (bearBias2 > 0) then 1 else 0; def crossmade2 = if (madebad < masterEMADLine) and crossmadeup and (bullBias2 > 0) then 1 else if (madebad > masterEMADLine) and crossmadedn and (bearBias2 > 0) then -1 else 0; def crossmade0 = if (!crossmade2[1] or !crossmade2[1]) and (crossmade2 == 0) then 1 else 0; ##################################################### ## ## ##################################################### def pd = 22; def bbl = 20; def mult = 2.0; def lb = 50; def ph = 0.85; def ltLB = 40; def mtLB = 14; def str = 3; def wvf = ((Highest(close, pd) - low) / (Highest(close, pd))) * 100; def sDev = mult * StDev(wvf, bbl); def midLine1 = SimpleMovingAvg(wvf, bbl); def lowerBand1 = midLine1 - sDev; def upperBand1 = midLine1 + sDev; def rangeHigh = (Highest(wvf, lb)) * ph; def upRange = low > low[1] and close > high[1]; def upRange_Aggr = close > close[1] and close > open[1]; def filtered = ((wvf[1] >= upperBand1[1] or wvf[1] >= rangeHigh[1]) and (wvf < upperBand1 and wvf < rangeHigh)); def filtered_Aggr = (wvf[1] >= upperBand1[1] or wvf[1] >= rangeHigh[1]); def alert4 = upRange_Aggr and close > close[str] and (close < close[ltLB] or close < close[mtLB]) and filtered_Aggr; def alert4close = if alert4 then close else 0; def crossmade = if (madebad < masterEMADLine) and crossmadeup then 1 else if (madebad > masterEMADLine) and crossmadedn then -1 else 0; def madedn = (madebad > masterEMADLine); def madeup = (madebad < masterEMADLine); def made2 = madebadavg; def made3 = if !madedn and (made2 <= zerolinedata) then madebadavg else double.nan; def made4 = if !madeup and (made2 >= zerolinedata) then madebadavg else double.nan; def madecrossupavg = if made2 crosses below masterEMADLine then 1 else 0; def madecrossdownavg = if made2 crosses above masterEMADLine then 1 else 0; def crossmadelogicup = if madecrossupavg and !madecrossupavg[1] then 1 else 0; def crossmadelogicdown = if madecrossdownavg and !madecrossdownavg[1] then 1 else 0; def crossmademorelogicup = if crossmadelogicup and crosslinelogic and emadup[1] then 1 else 0; def crossmademorelogicdown = if crossmadelogicdown and !crosslinelogic and emaddown[1] then 1 else 0; def EmaPushStepUp = if topBandStepUp and EmadUp and (((upperEMADLine) - bottomband) == 0) then 1 else 0;; def EmaPushStepDown = if bottomBandStepDown and EmadDown and (((lowerEMADLine) - bottomband) == 0) then 1 else 0; def HLFilter = if HL[1] < HL then 1 else 0; def LHFilter = if LH[1] > LH then 1 else 0; def HLFilter2 = if HL[2] < HL[1] then 1 else 0; def LHFilter2 = if LH[2] > LH[1] then 1 else 0; ##################################################### ## ## ##################################################### def ValueUp_lookback = fold index1 = 1 to filterBounceArrows with x1 do x1 + absvalue(valueUp)[index1]; def ValueDown_lookback = fold index2 = 1 to filterBounceArrows with x2 do x2 + absvalue(valueDown)[index2]; def topBandStepDown_lookback = fold index3 = 1 to Steplookback with x3 do x3 + topBandStepDown[index3]; def topBandStepUp_lookback = fold index4 = 1 to Steplookback with x4 do x4 + topBandStepUp[index4]; def bottomBandStepDown_lookback = fold index5 = 1 to Steplookback with x5 do x5 + bottomBandStepDown[index5]; def bottomBandStepUp_lookback = fold index6 = 1 to Steplookback with x6 do x6 + bottomBandStepUp[index6]; def bothBandsDown_lookback = fold index7 = 1 to filterBounceArrows with x7 do x7 + bothBandsDown[index7]; def bothBandsUp_lookback = fold index8 = 1 to filterBounceArrows with x8 do x8 + bothBandsUp[index8]; def bullBias_lookback = fold index9 = 1 to filterBounceArrows with x9 do x9 + bullBias[index9]; def bearBias_lookback = fold index10 = 1 to filterBounceArrows with x10 do x10 + bearBias[index10]; def crossesUpZeroline_lookback = fold index11 = 1 to filterZeroline with x11 do x11 + crossesUpZeroline[index11]; def crossesDownZeroline_lookback = fold index12 = 1 to filterZeroline with x12 do x12 + crossesDownZeroline[index12]; def crossesUpBottomline_lookback = fold index13 = 1 to filterBounceArrows with x13 do x13 + crossesUpline[index13]; def crossesDownTopline_lookback = fold index14 = 1 to filterBounceArrows with x14 do x14 + crossesDownline[index14]; def CrossedUPaboveZero_lookback = fold index15 = 1 to crossabovebelowzero with x15 do x15 + crossesUpZeroline[index15]; def CrossedDOWNbelowZero_lookback = fold index16 = 1 to crossabovebelowzero with x16 do x16 + crossesDownZeroline[index16]; def HL_lookback = fold index17 = 1 to LHHL_Lookback with x17 do x17 + HL[index17]; def LH_lookback = fold index18 = 1 to LHHL_Lookback with x18 do x18 + LH[index18]; def upabovezero_lookback = fold index19 = 1 to crossabovebelowzero with x19 do x19 + HL[index19]; def downbelowzero_lookback = fold index20 = 1 to crossabovebelowzero with x20 do x20 + LH[index20]; def PriceMonitor = fold index21 = 1 to crossabovebelowzero with x21 do x21 + HL[index21]; def ExtremeBuy1_lookback = fold index24 = 1 to filter_3x with x24 do x24 + ExtremeBuy1[index24]; def ExtremeSell1_lookback = fold index25 = 1 to filter_3x with x25 do x25 + ExtremeSell1[index25]; def RegularSell1_lookback = fold index26 = 1 to filter_3x with x26 do x26 + RegularSell1[index26]; def RegularBuy1_lookback = fold index27 = 1 to filter_3x with x27 do x27 + RegularBuy1[index27]; def Squeeze_lookback = fold index28 = 1 to SqueezeLook with x28 do x28 + Squeeze_Alert_1[index28]; def ElCrossDN_lookback = fold index29 = 1 to filterBounceArrows with x29 do x29 + ElCrossDN[index29]; def ElCrossUP_lookback = fold index30 = 1 to filterBounceArrows with x30 do x30 + ElCrossUP[index30]; def bearBias2_lookback = fold index31 = 1 to filterBounceArrows with x31 do x31 + bearBias2[index31]; def bullBias2_lookback = fold index32 = 1 to filterBounceArrows with x32 do x32 + bullBias2[index32]; def crossmade0_lookback = fold index33 = 1 to cloudlinelook with x33 do x33 + crossmade0[index33]; def alert4_lookback = fold index34 = 1 to alert4lookback with x34 do x34 + alert4close[index34]; ##################################################### ## ## ##################################################### def bubblehidertopdown = topBandStepDown_lookback > PreviousStepsDown; def bubblehidertopup = topBandStepup_lookback > PreviousStepsUp; def bubblehiderbottomdown = bottomBandStepDown_lookback > PreviousStepsDown; def bubblehiderbottomup = bottomBandStepup_lookback > PreviousStepsUp; def UP1 = if marketopen and (!bubblehidertopdown or !bubblehiderbottomdown) and !EmaPushStepDown and crossmademorelogicup then midBand else double.nan; def DOWN1 = if marketopen and (!bubblehidertopup or !bubblehiderbottomup) and !EmaPushStepUp and crossmademorelogicdown then midBand else double.nan; ##################################################### ## ## ##################################################### plot zeroLine = zerolinedata; plot Squeeze_Alert = if sqzLevel then (upperEMADLine + lowerEMADLine) / 2 else (upperEMADLine + lowerEMADLine) / 2 ; plot ExtremeBuy = if showTripleExh and sellerExtreme[1] and !sellerExtreme then midband else Double.NaN; plot ExtremeSell = if showTripleExh and buyerExtreme[1] and !buyerExtreme then midband else Double.NaN; plot RegularSell = if showTripleExh and buyerRegular[1] and !buyerRegular then midband else Double.NaN; plot RegularBuy = if showTripleExh and sellerRegular[1] and !sellerRegular then midband else Double.NaN; plot topBandPlot = topBand; plot bottomBandPlot = bottomBand; plot upperEMADLinePlot = upperEMADLine; plot lowerEMADLinePlot = lowerEMADLine; plot masterEMADLinePlot2 = (upperEMADLine + lowerEMADLine) / 2; plot masterEMADLinePlot = ((upperEMADLinePlot + lowerEMADLinePlot) / 2); plot made1 = made4; plot made = made3; plot UP = UP1; plot DOWN = DOWN1; plot firstHL = if showHLLH and trackCrUp and !trackCrUp[1] then lowerEMADLine else double.nan; plot firstLH = if showHLLH and trackCrDn and !trackCrDn[1] then lowerEMADLine else double.nan; plot secondHL = if showHLLH and trackCrUp2 and !trackCrUp2[1] and !crossesUpline then lowerEMADLine else double.nan; plot secondLH = if showHLLH and trackCrDn2 and !trackCrDn2[1] and !crossesDownline then lowerEMADLine else double.nan; ##################################################### ## ## ##################################################### def firstHL2 = if trackCrUp and !trackCrUp[1] then 1 else 0; def firstLH2 = if trackCrDn and !trackCrDn[1] then 1 else 0; def HLBuy = if firstHL2 and regularsell1 or extremesell1 then 1 else 0; def LHSell = if firstHL2 and regularbuy1 or extremebuy1 then 1 else 0; ##################################################### ## ## ##################################################### UP.SetPaintingStrategy(PaintingStrategy.ARROW_UP); UP.SetLineWeight(1); UP.SetDefaultColor(Color.white); UP.HideBubble(); UP.HideTitle(); ##################################################### ## ## ##################################################### DOWN.SetPaintingStrategy(PaintingStrategy.ARROW_DOWN); DOWN.SetLineWeight(1); DOWN.SetDefaultColor(Color.white); DOWN.HideBubble(); DOWN.HideTitle(); ##################################################### ## ## ##################################################### made1.AssignValueColor( if crossmade2 == 1 then color.dark_green else if crossmade2 == -1 then color.dark_red else if crossmade0_lookback > 1 and crosslinelogic then Color.gray else color.dark_red); ##################################################### ## ## ##################################################### made.AssignValueColor( if crossmade2 == 1 then color.dark_green else if crossmade2 == -1 then color.dark_red else if crossmade0_lookback > 1 and crosslinelogic then Color.gray else color.dark_red); ##################################################### ## ## ##################################################### Squeeze_Alert.SetPaintingStrategy(PaintingStrategy.line); Squeeze_Alert.SetLineWeight(2); Squeeze_Alert.SetDefaultColor(Color.YELLOW); ##################################################### ## ## ##################################################### RegularBuy.SetPaintingStrategy(PaintingStrategy.ARROW_UP); ExtremeBuy.SetPaintingStrategy(PaintingStrategy.ARROW_UP); RegularSell.SetPaintingStrategy(PaintingStrategy.ARROW_DOWN); ExtremeSell.SetPaintingStrategy(PaintingStrategy.ARROW_DOWN); ##################################################### ## ## ##################################################### RegularBuy.SetLineWeight((1)); ExtremeBuy.SetLineWeight((1)); RegularSell.SetLineWeight((1)); ExtremeSell.SetLineWeight((1)); ##################################################### ## ## ##################################################### ExtremeSell.SetDefaultColor((Color.WHITE)); ExtremeBuy.SetDefaultColor((Color.WHITE)); RegularBuy.SetDefaultColor((Color.white)); RegularSell.SetDefaultColor((Color.white)); ##################################################### ## ## ##################################################### firstHL.SetPaintingStrategy(PaintingStrategy.ARROW_UP); firstHL.SetLineWeight(1); firstHL.SetDefaultColor(Color.blue); firstHL.HideBubble(); firstHL.HideTitle(); ##################################################### ## ## ##################################################### firstLH.SetPaintingStrategy(PaintingStrategy.ARROW_DOWN); firstLH.SetLineWeight(1); firstLH.SetDefaultColor(Color.blue); firstLH.HideBubble(); firstLH.HideTitle(); ##################################################### ## ## ##################################################### secondHL.SetPaintingStrategy(PaintingStrategy.ARROW_UP); secondHL.SetLineWeight(1); secondHL.SetDefaultColor(Color.CYAN); secondHL.HideBubble(); secondHL.HideTitle(); ##################################################### ## ## ##################################################### secondLH.SetPaintingStrategy(PaintingStrategy.ARROW_DOWN); secondLH.SetLineWeight(1); secondLH.SetDefaultColor(Color.CYAN); secondLH.HideBubble(); secondLH.HideTitle(); ##################################################### ## ## ##################################################### masterEMADLinePlot.SetPaintingStrategy(PaintingStrategy.histogram); masterEMADLinePlot.HideBubble(); masterEMADLinePlot.SetLineWeight(1); masterEMADLinePlot.AssignValueColor( if alert4 then color.cyan else if HLBuy then color.light_green else if LHSell then color.light_red else if crossmade2up then Color.dark_green else if crossmade2dn then color.dark_red else if crossmade0_lookback > 1 and crosslinelogic then Color.dark_gray else color.dark_red ); DefineGlobalColor("G0", CreateColor(0, 255, 0)); #Green DefineGlobalColor("G1", CreateColor(0, 229, 0)); #Green DefineGlobalColor("G2", CreateColor(0, 206, 0)); #Green DefineGlobalColor("G3", CreateColor(0, 186, 0)); #Green DefineGlobalColor("G4", CreateColor(0, 167, 0)); #Green DefineGlobalColor("G5", CreateColor(0, 151, 0)); #Green DefineGlobalColor("G6", CreateColor(0, 136, 0)); #Green DefineGlobalColor("G7", CreateColor(0, 122, 0)); #Green DefineGlobalColor("G8", CreateColor(0, 109, 0)); #Green DefineGlobalColor("G9", CreateColor(0, 98, 0)); #Green DefineGlobalColor("R0", CreateColor(255, 0, 0)); #Red DefineGlobalColor("R1", CreateColor(224, 0, 0)); #Red DefineGlobalColor("R2", CreateColor(197, 0, 0)); #Red DefineGlobalColor("R3", CreateColor(174, 0, 0)); #Red DefineGlobalColor("R4", CreateColor(153, 0, 0)); #Red DefineGlobalColor("R5", CreateColor(135, 0, 0)); #Red DefineGlobalColor("R6", CreateColor(118, 0, 0)); #Red DefineGlobalColor("R7", CreateColor(104, 0, 0)); #Red DefineGlobalColor("R8", CreateColor(92, 0, 0)); #Red DefineGlobalColor("R9", CreateColor(81, 0, 0)); #Red upperEMADLinePlot.HideTitle(); upperEMADLinePlot.HideBubble(); upperEMADLinePlot.AssignValueColor( if (lowerEMADLinePlot > upperEMADLinePlot) then createcolor(153, 0, 0) else if (lowerEMADLinePlot < upperEMADLinePlot) then createcolor(0, 167, 0) else GlobalColor("Gray") ); lowerEMADLinePlot.HideTitle(); lowerEMADLinePlot.HideBubble(); lowerEMADLinePlot.AssignValueColor( if (lowerEMADLinePlot > upperEMADLinePlot) then Color.red else if (lowerEMADLinePlot < upperEMADLinePlot) then Color.green else GlobalColor("Gray") ); masterEMADLinePlot2.HideTitle(); masterEMADLinePlot2.HideBubble(); masterEMADLinePlot2.SetLineWeight(emadLineWeight); masterEMADLinePlot2.AssignValueColor( if masterEMADLinePlot > masterEMADLinePlot[2] then createColor(0, 186, 0) else if masterEMADLinePlot < masterEMADLinePlot[2] then createColor(174, 0, 0) else GlobalColor("Gray") ); zeroLine.HideTitle(); zeroLine.HideBubble(); zeroLine.AssignValueColor( if (upperEMADLinePlot > zeroLine) then Color.green else if (upperEMADLinePlot < zeroLine) then Color.red else GlobalColor("Yellow") ); topBandPlot.HideTitle(); topBandPlot.HideBubble(); topBandPlot.AssignValueColor( if bothBandsDown then Color.dark_red else if bothBandsUp then color.Dark_green else if topBandStepUp then Color.green else if topBandStepDown then Color.red else if bearBias then Color.yellow else GlobalColor("Gray") ); bottomBandPlot.HideTitle(); bottomBandPlot.HideBubble(); bottomBandPlot.AssignValueColor( if bothBandsDown then Color.dark_red else if bothBandsUp then color.Dark_green else if bottomBandStepUp then Color.green else if bottomBandStepDown then Color.red else if bullBias then Color.yellow else GlobalColor("Gray") ); AddLabel(yes, " EMAD RANGE V1000 ", color.WHITE); AddLabel(ShowColorCodeLabel, if showHowToLabel then " Bullish: Observe cloud prior to reversal " else " Bullish ", color.dark_green); AddLabel(ShowColorCodeLabel, if showHowToLabel then " Bearish: Observe cloud prior to reversal " else " Bearish ", color.dark_red); AddLabel(ShowColorCodeLabel, if showHowToLabel then " Vix Alert4: Bounce incoming " else " Vix Alert4 ", color.cyan); AddLabel(ShowColorCodeLabel, if showHowToLabel then " Seller Exhaustion: Watch for pullback / reversal when exhaustion ends " else " Seller Exhaustion ", color.light_red); AddLabel(ShowColorCodeLabel, if showHowToLabel then " Seller Exhaustion: Watch for pullback / reversal when exhaustion ends " else " Buyer Exhaustion ", color.light_green); AddLabel(ShowColorCodeLabel, if showHowToLabel then " Neutral: Direction not confirmed " else " Neutral ", color.gray); AddLabel(ShowColorCodeLabel, if showHowToLabel then " Squeeze: (non-directional) potential strong move incoming " else " Squeeze ", color.yellow); ##################################################### ## ## ##################################################### AddCloud(if showEMACloud and (made1 > masterEMADLinePlot) then made1 else Double.NaN, masterEMADLinePlot, Color.dark_red, Color.gray); AddCloud(if showEMACloud and (masterEMADLinePlot >= made) then masterEMADLinePlot else Double.NaN, made, Color.dark_green, Color.gray); ##################################################### ## ## ##################################################### AddChartBubble(showBubbles and crossesUpline and crossesUpline_filter, midBand, "Wait for HL", GlobalColor("Green"), no); AddChartBubble(showBubbles and crossesDownline and crossesDownline_filter, midBand,"Wait for LH" , GlobalColor("Red"), yes); ##################################################### ## ## ##################################################### AddVerticalLine(showVerticalline and crossesUpline and crossesUpline_filter, "", GlobalColor("Green"), no); AddVerticalLine(showVerticalline and crossesDownline and crossesDownline_filter,"" , GlobalColor("Red"), yes);
Haha! Nice, The green and red dots have been removed but I will add them back and share it. They were removed due to the following: the light green and dark green candles are triple exhaustion. The dots indicate the “end of exhaustion” so when those candle colors end is the same indication. Also the Emad Range (in the screenshot) includes the light green and light red bars which are the equivalent of the red and green dots.
If you are referring the the green and red line (C3 line) through the candles… there is a way… LOAD THE NEWEST CHART STYLE WITHOUT THE LINE! Haha but that would be my suggestion, believe me I have tried to mess with the settings and made an mtf version but at the end of the day it is not necessary especially considering it seems to be too fast of an indication for your trading style.
My first suggestion would be to scrap the Balance lower… first notice EMAD providing a similar indication…as for the dotted line with gray dots look at the grey candles in the upper. Looking at too many indicators is a distraction… that being said… if you are scalping 2 points or 100 points on the one min or the daily the entry methods remain the same as in page one.
Good sir… saying MACD on this thread is like a horrible offensive curse word! Jk but… MACD is in nearly all indicators in the chart style… but to each his own.
Also the circled “fake breakouts” are not what I would consider a fake breakout… notice before the first circle candles had broken down below the OB zone so that first circle where the candle pulls back up and rejects re entry into the zone is the safe short entry not before. Then the next circled candle is below the red cloud… a signal to hold short or enter a short if it rejects but being under the cloud should make you feel a little more confident about holding through that green candle.
DId you ever get an answer to this question?
useThinkScript is the #1 community of stock market investors using indicators and other tools to power their trading strategies. Traders of all skill levels use our forums to learn about scripting and indicators, help each other, and discover new ways to gain an edge in the markets.
We get it. Our forum can be intimidating, if not overwhelming. With thousands of topics, tens of thousands of posts, our community has created an incredibly deep knowledge base for stock traders. No one can ever exhaust every resource provided on our site.
If you are new, or just looking for guidance, here are some helpful links to get you started.
