Fractal Basic Chart Patterns [MyTradingCoder]This script is something that I made a long time ago in my early days of learning Pine. It is not in development anymore but has some unique and impressive utility that will help the community. This script will fractally identify chart patterns(iH&S,H&S,W,M) on any chart and timeframe. Most scripts have limitations that make the user have to adjust various parameters to get the desired result to show up on the chart. Lower input values may show smaller patterns, whereas vise versa, higher input values may show larger patterns, but you never seem to get the best of both worlds with these types of scripts. Some users may appreciate the vast majority of input parameters that most scripts provide, but others like myself may find it restrictive and annoying, as you wont get large patterns AND small patterns simultaneously.
All details needed to understand how to use the script are listed below. I will be creating new and well written scripts in the near future moving forward to help the community as best as I can, and just wanted to make it clear that this particular script is just something that I had on the backburner from a very long time ago, before I was a "Pinescript Maven" :) Enjoy!
Available Patterns:
- W Pattern
- M Pattern
- Head and Shoulders Pattern
- Inverse Head and Shoulder Pattern
Customizable inputs:
- Option to specify minimum bars required to consider a pattern.(Can be helpful if you don't want to see lower timeframe patterns, as some may not look like patterns, but if you drop the timeframe and go to the same time, there will be a pattern there on a lower scale)
- Boolean Inputs to Enable/Disable Certain Patterns
Available Alert Options:
- W Pattern Alert
- M Pattern Alert
- H&S Pattern Alert
- iH&S Pattern Alert
User Manual:
- Patterns will be drawn/detected/finalized on the bar close when the neckline is broken
- Green/Red lines represent the historical structure used to identify each pattern
- Blue dashed lines represent the projected price action based on the pattern completing
- Alerts/Indicator will not repaint(Can use 'once per bar' or 'once per bar close' and behavior will be identical. Code is optimized.)
- May have trouble on assets with daily/weekend time gaps with the projected price action dashed line due to time being used as the xloc. If this becomes a problem, leave a comment below and I will consider bringing this back into development and convert to bar_index as xloc to fix the issue.
- Patterns can be all shapes and sizes, hence the beauty of this indicator
- Leave a comment below for any questions or requests and give the indicator a like if you find it useful
Patterns
Fibonacci Timing PatternThe Fibonacci Timing Pattern is a price-based counter that seeks to determine short-term and medium-term reversals in price action. It is based on the following set of conditions:
* For a bullish Fibonacci timing signal: The market must shape 8 consecutive close prices where each close price is lower than the close prices from 3 and 5 periods ago.
* For a bearish Fibonacci timing signal: The market must shape 8 consecutive close prices where each close price is higher than the close prices from 3 and 5 periods ago.
The signals of the pattern are ideally used in a sideways market or used in tandem with the trend (bullish signals are taken in a bullish market and bearish signals are taken in a bearish market).
Head and Shoulders - Quasimodo etc Pattern Recognition RENKODisclaimer: Only use this pattern recognition on a RENKO chart. Renko charts plot different than traditional candles and therefore do not represent all price moves. There is a possibility of repainting while using ATR based renko charts so past results are not a 100% accurate representation of future results. Use this indicator as a part of your strategy and not as your only means of obtaining gains in the market.
Hello traders, it has been said time and time again that algorithmic software is unable to identify complex market structure like head and shoulders, quasimodo, triangle patterns and other methods humans use to base their trading decisions on. With this indicator I intend to completely crush that assumption and prove that it actualy is possible. Ofcourse an indicator is less likely to find all variation on a chart pattern and a human is probably still your best bet in finding these patterns early.
That is wy this indicator does not only use textbook patterns and has 7 variation on head and shoulders build into it. I will keep updating this indicator if I see it missed some crucial patterns. Right now it has a total of 38 patterns build into it with them being grouped under specific names. Feel free to turn off any pattern you do not like to see.
Renko patterns solve the problem of time and chaos in the markets which have been the biggest hurdle in pattern recognition software as the amount of variations to account for is just too great a number. With this script using renko it will soon be able to identify any pattern in the market and I plan to add Wyckoff to it in the future, right now I have a beta version of Wyckoff build into it but planning to add better version of it in the future. The amount of variations on Wyckoff is quite extreme so it will take a very long time to get an optimised Wyckoff identification system.
If you do not want to miss patterns I recommend to use a multi chart aproach so that you can find patterns in multiple renko brick sizes at the same time to find more entrys.
Feel free to comment any pattern you want me to add and let's make the most dedicated pattern recognition software on this platform.
Regards
HonestCowboy
Naked Bar Upward ReversalAMEX:SPY
The Naked Bar Upward Reversal is a three bar candlestick pattern with an inside candle as a entry point. This pattern is bullish since it has a candle closing red from the previous candle; the most bearish pattern possible. The following inside candle is a reversal of its previous candle with an open above the previous candle's close. Look to buy the next open above the inside candle's close.
This is a bullish reversal pattern and should be used in this context. Successful entries are found in corrections along an upward trend, or buying into a dip. Performance drops when the pattern appears at tops. To improve profitability, use a cluster of evidence to enhance the performance of this pattern. The intended time frame is within the daily and weekly.
BjCandlePatternsLibrary "BjCandlePatterns"
Patterns is a Japanese candlestick pattern recognition Library for developers. Functions here within detect viable setups in a variety of popular patterns. Please note some patterns are without filters such as comparisons to average candle sizing, or trend detection to allow the author more freedom.
doji(dojiSize, dojiWickSize) Detects "Doji" candle patterns
Parameters:
dojiSize : (float) The relationship of body to candle size (ie. body is 5% of total candle size). Default is 5.0 (5%)
dojiWickSize : (float) Maximum wick size comparative to the opposite wick. (eg. 2 = bottom wick must be less than or equal to 2x the top wick). Default is 2
Returns: (series bool) True when pattern detected
dLab(showLabel, labelColor, textColor) Produces "Doji" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
bullEngulf(maxRejectWick, mustEngulfWick) Detects "Bullish Engulfing" candle patterns
Parameters:
maxRejectWick : (float) Maximum rejection wick size.
The maximum wick size as a percentge of body size allowable for a top wick on the resolution candle of the pattern. 0.0 disables the filter.
eg. 50 allows a top wick half the size of the body. Default is 0% (Disables wick detection).
mustEngulfWick : (bool) input to only detect setups that close above the high prior effectively engulfing the candle in its entirety. Default is false
Returns: (series bool) True when pattern detected
bewLab(showLabel, labelColor, textColor) Produces "Bullish Engulfing" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
bearEngulf(maxRejectWick, mustEngulfWick) Detects "Bearish Engulfing" candle patterns
Parameters:
maxRejectWick : (float) Maximum rejection wick size.
The maximum wick size as a percentge of body size allowable for a bottom wick on the resolution candle of the pattern. 0.0 disables the filter.
eg. 50 allows a botom wick half the size of the body. Default is 0% (Disables wick detection).
mustEngulfWick : (bool) Input to only detect setups that close below the low prior effectively engulfing the candle in its entirety. Default is false
Returns: (series bool) True when pattern detected
bebLab(showLabel, labelColor, textColor) Produces "Bearish Engulfing" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
hammer(ratio, shadowPercent) Detects "Hammer" candle patterns
Parameters:
ratio : (float) The relationship of body to candle size (ie. body is 33% of total candle size). Default is 33%.
shadowPercent : (float) The maximum allowable top wick size as a percentage of body size. Default is 5%.
Returns: (series bool) True when pattern detected
hLab(showLabel, labelColor, textColor) Produces "Hammer" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
star(ratio, shadowPercent) Detects "Star" candle patterns
Parameters:
ratio : (float) The relationship of body to candle size (ie. body is 33% of total candle size). Default is 33%.
shadowPercent : (float) The maximum allowable bottom wick size as a percentage of body size. Default is 5%.
Returns: (series bool) True when pattern detected
ssLab(showLabel, labelColor, textColor) Produces "Star" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
dragonflyDoji() Detects "Dragonfly Doji" candle patterns
Returns: (series bool) True when pattern detected
ddLab(showLabel, labelColor) Produces "Dragonfly Doji" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
Returns: (series label) A label visible at the chart level intended for the title pattern
gravestoneDoji() Detects "Gravestone Doji" candle patterns
Returns: (series bool) True when pattern detected
gdLab(showLabel, labelColor, textColor) Produces "Gravestone Doji" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
tweezerBottom(closeUpperHalf) Detects "Tweezer Bottom" candle patterns
Parameters:
closeUpperHalf : (bool) input to only detect setups that close above the mid-point of the candle prior increasing its bullish tendancy. Default is false
Returns: (series bool) True when pattern detected
tbLab(showLabel, labelColor, textColor) Produces "Tweezer Bottom" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
tweezerTop(closeLowerHalf) Detects "TweezerTop" candle patterns
Parameters:
closeLowerHalf : (bool) input to only detect setups that close below the mid-point of the candle prior increasing its bearish tendancy. Default is false
Returns: (series bool) True when pattern detected
ttLab(showLabel, labelColor, textColor) Produces "TweezerTop" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
spinningTopBull(wickSize) Detects "Bullish Spinning Top" candle patterns
Parameters:
wickSize : (float) input to adjust detection of the size of the top wick/ bottom wick as a percent of total candle size. Default is 34%, which ensures the wicks are both larger than the body.
Returns: (series bool) True when pattern detected
stwLab(showLabel, labelColor, textColor) Produces "Bullish Spinning Top" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
spinningTopBear(wickSize) Detects "Bearish Spinning Top" candle patterns
Parameters:
wickSize : (float) input to adjust detection of the size of the top wick/ bottom wick as a percent of total candle size. Default is 34%, which ensures the wicks are both larger than the body.
Returns: (series bool) True when pattern detected
stbLab(showLabel, labelColor, textColor) Produces "Bearish Spinning Top" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
spinningTop(wickSize) Detects "Spinning Top" candle patterns
Parameters:
wickSize : (float) input to adjust detection of the size of the top wick/ bottom wick as a percent of total candle size. Default is 34%, which ensures the wicks are both larger than the body.
Returns: (series bool) True when pattern detected
stLab(showLabel, labelColor, textColor) Produces "Spinning Top" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
morningStar() Detects "Bullish Morning Star" candle patterns
Returns: (series bool) True when pattern detected
msLab(showLabel, labelColor, textColor) Produces "Bullish Morning Star" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
eveningStar() Detects "Bearish Evening Star" candle patterns
Returns: (series bool) True when pattern detected
esLab(showLabel, labelColor, textColor) Produces "Bearish Evening Star" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
haramiBull() Detects "Bullish Harami" candle patterns
Returns: (series bool) True when pattern detected
hwLab(showLabel, labelColor, textColor) Produces "Bullish Harami" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
haramiBear() Detects "Bearish Harami" candle patterns
Returns: (series bool) True when pattern detected
hbLab(showLabel, labelColor, textColor) Produces "Bearish Harami" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
haramiBullCross() Detects "Bullish Harami Cross" candle patterns
Returns: (series bool) True when pattern detected
hcwLab(showLabel, labelColor, textColor) Produces "Bullish Harami Cross" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
haramiBearCross() Detects "Bearish Harami Cross" candle patterns
Returns: (series bool) True when pattern detected
hcbLab(showLabel, labelColor) Produces "Bearish Harami Cross" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
Returns: (series label) A label visible at the chart level intended for the title pattern
marubullzu() Detects "Bullish Marubozu" candle patterns
Returns: (series bool) True when pattern detected
mwLab(showLabel, labelColor, textColor) Produces "Bullish Marubozu" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
marubearzu() Detects "Bearish Marubozu" candle patterns
Returns: (series bool) True when pattern detected
mbLab(showLabel, labelColor, textColor) Produces "Bearish Marubozu" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
abandonedBull() Detects "Bullish Abandoned Baby" candle patterns
Returns: (series bool) True when pattern detected
abwLab(showLabel, labelColor, textColor) Produces "Bullish Abandoned Baby" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
abandonedBear() Detects "Bearish Abandoned Baby" candle patterns
Returns: (series bool) True when pattern detected
abbLab(showLabel, labelColor, textColor) Produces "Bearish Abandoned Baby" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
piercing() Detects "Piercing" candle patterns
Returns: (series bool) True when pattern detected
pLab(showLabel, labelColor, textColor) Produces "Piercing" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
darkCloudCover() Detects "Dark Cloud Cover" candle patterns
Returns: (series bool) True when pattern detected
dccLab(showLabel, labelColor, textColor) Produces "Dark Cloud Cover" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
tasukiBull() Detects "Upside Tasuki Gap" candle patterns
Returns: (series bool) True when pattern detected
utgLab(showLabel, labelColor, textColor) Produces "Upside Tasuki Gap" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
tasukiBear() Detects "Downside Tasuki Gap" candle patterns
Returns: (series bool) True when pattern detected
dtgLab(showLabel, labelColor, textColor) Produces "Downside Tasuki Gap" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
risingThree() Detects "Rising Three Methods" candle patterns
Returns: (series bool) True when pattern detected
rtmLab(showLabel, labelColor, textColor) Produces "Rising Three Methods" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
fallingThree() Detects "Falling Three Methods" candle patterns
Returns: (series bool) True when pattern detected
ftmLab(showLabel, labelColor, textColor) Produces "Falling Three Methods" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
risingWindow() Detects "Rising Window" candle patterns
Returns: (series bool) True when pattern detected
rwLab(showLabel, labelColor, textColor) Produces "Rising Window" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
fallingWindow() Detects "Falling Window" candle patterns
Returns: (series bool) True when pattern detected
fwLab(showLabel, labelColor, textColor) Produces "Falling Window" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
kickingBull() Detects "Bullish Kicking" candle patterns
Returns: (series bool) True when pattern detected
kwLab(showLabel, labelColor, textColor) Produces "Bullish Kicking" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
kickingBear() Detects "Bearish Kicking" candle patterns
Returns: (series bool) True when pattern detected
kbLab(showLabel, labelColor, textColor) Produces "Bearish Kicking" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
lls(ratio) Detects "Long Lower Shadow" candle patterns
Parameters:
ratio : (float) A relationship of the lower wick to the overall candle size expressed as a percent. Default is 75%
Returns: (series bool) True when pattern detected
llsLab(showLabel, labelColor, textColor) Produces "Long Lower Shadow" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
lus(ratio) Detects "Long Upper Shadow" candle patterns
Parameters:
ratio : (float) A relationship of the upper wick to the overall candle size expressed as a percent. Default is 75%
Returns: (series bool) True when pattern detected
lusLab(showLabel, labelColor, textColor) Produces "Long Upper Shadow" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
bullNeck() Detects "Bullish On Neck" candle patterns
Returns: (series bool) True when pattern detected
nwLab(showLabel, labelColor, textColor) Produces "Bullish On Neck" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
bearNeck() Detects "Bearish On Neck" candle patterns
Returns: (series bool) True when pattern detected
nbLab(showLabel, labelColor, textColor) Produces "Bearish On Neck" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
soldiers(wickSize) Detects "Three White Soldiers" candle patterns
Parameters:
wickSize : (float) Maximum allowable top wick size throughout pattern expressed as a percent of total candle height. Default is 5%
Returns: (series bool) True when pattern detected
wsLab(showLabel, labelColor, textColor) Produces "Three White Soldiers" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
crows(wickSize) Detects "Three Black Crows" candle patterns
Parameters:
wickSize : (float) Maximum allowable bottom wick size throughout pattern expressed as a percent of total candle height. Default is 5%
Returns: (series bool) True when pattern detected
bcLab(showLabel, labelColor, textColor) Produces "Three Black Crows" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
triStarBull() Detects "Bullish Tri-Star" candle patterns
Returns: (series bool) True when pattern detected
tswLab(showLabel, labelColor, textColor) Produces "Bullish Tri-Star" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
triStarBear() Detects "Bearish Tri-Star" candle patterns
Returns: (series bool) True when pattern detected
tsbLab(showLabel, labelColor, textColor) Produces "Bearish Tri-Star" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
wrap(cond, barsBack, borderColor, bgcolor) Produces a box wrapping the highs and lows over the look back.
Parameters:
cond : (series bool) Condition under which to draw the box.
barsBack : (series int) the number of bars back to begin drawing the box.
borderColor : (series color) Color of the four borders. Optional. The default is color.gray.
bgcolor : (series color) Background color of the box. Optional. The default is color.gray.
Returns: (series box) A box who's top and bottom are above and below the highest and lowest points over the lookback
topWick() returns the top wick size of the current candle
Returns: (series float) A value equivelent to the distance from the top of the candle body to its high
bottomWick() returns the bottom wick size of the current candle
Returns: (series float) A value equivelent to the distance from the bottom of the candle body to its low
body() returns the body size of the current candle
Returns: (series float) A value equivelent to the distance between the top and the bottom of the candle body
highestBody() returns the highest body of the current candle
Returns: (series float) A value equivelent to the highest body, whether it is the open or the close
lowestBody() returns the lowest body of the current candle
Returns: (series float) A value equivelent to the highest body, whether it is the open or the close
barRange() returns the height of the current candle
Returns: (series float) A value equivelent to the distance between the high and the low of the candle
bodyPct() returns the body size as a percent
Returns: (series float) A value equivelent to the percentage of body size to the overall candle size
midBody() returns the price of the mid-point of the candle body
Returns: (series float) A value equivelent to the center point of the distance bewteen the body low and the body high
bodyupGap() returns true if there is a gap up between the real body of the current candle in relation to the candle prior
Returns: (series bool) true if there is a gap up and no overlap in the real bodies of the current candle and the preceding candle
bodydwnGap() returns true if there is a gap down between the real body of the current candle in relation to the candle prior
Returns: (series bool) true if there is a gap down and no overlap in the real bodies of the current candle and the preceding candle
gapUp() returns true if there is a gap down between the real body of the current candle in relation to the candle prior
Returns: (series bool) true if there is a gap down and no overlap in the real bodies of the current candle and the preceding candle
gapDwn() returns true if there is a gap down between the real body of the current candle in relation to the candle prior
Returns: (series bool) true if there is a gap down and no overlap in the real bodies of the current candle and the preceding candle
dojiBody() returns true if the candle body is a doji
Returns: (series bool) true if the candle body is a doji. Defined by a body that is 5% of total candle size
Harmonic Pattern Detection [LuxAlgo]Harmonic patterns make up a major part of the many patterns traders use to make investment decisions. The following tool aims to automatically categorize which XABCD harmonic pattern is highlighted by the user and to alert when the price reaches the PRZ or D point.
The tool can categorize Bat, Gartley, Butterfly, and Crab patterns.
Settings
XA Precision: The Gartley and Butterfly patterns require precise ratios for the XA segment, this setting allows giving some headroom for the detection of these patterns. For example, the Gartley pattern requires a ratio for the XA segment of 0.618, using an XA precision of 0.01 will allow the segment to be considered correct if above 0.608 and under 0.628.
Bullish: Color of a bullish pattern
Bearish: Color of a bearish pattern
The X, A, B, C, D settings determine the location of the harmonic pattern vertices. The user does not need to change them from the settings, instead only requiring adjusting their location on the chart like with a regular drawing tool. Setting these vertices is required when adding the indicator to your chart.
Usage
Upon setting the harmonic pattern vertices, the segments, as well as each ratio and PRZ, will be displayed. A dashboard in the top right displays which harmonic pattern has been detected.
Detected bearish crab pattern on BTCUSD15.
Bullish butterfly pattern on MATICUSD15. It is important not to use an XA precision value that would return overlapping ranges between the Gartley/Harmonic and other patterns. Using the default value is recommended.
The upper limit of the PRZ is determined as vertex D plus 38.2% of segment DX, while the lower limit is the vertex D minus 38.2% of segment DX. Various methods exist for the determination of the PRZ, this one is general but the user can use one proper to the detected harmonic pattern.
Finally hovering on the label highlighting the segment ratios return the proper ratio used by each harmonic pattern for that precise segment.
HarmonicPatternLibrary "HarmonicPattern"
Functions to detect/check harmonic patterns from provided values.
line_price_rate(point_c, point_b, point_a) Compute the price rate of the line AB divided by the the line BC
Parameters:
point_c : float, the price at point C.
point_b : float, the price at point B.
point_a : float, the price at point A.
Returns: float
line_time_rate(_c, _b, _a) Compute the time rate of the line AB divided by the the line BC
Parameters:
_c : float, the time or bar_index at point C.
_b : float, the time or bar_index at point B.
_a : float, the time or bar_index at point A.
Returns: float
is_inrange(value, min, max) Check if value is within min/max range of tolerance.
Parameters:
value : float, value to check tolerance.
min : float, minimum value in range of tolerance.
max : float, maximum value in range of tolerance.
Returns: bool
isHarmonicTriangle(rate_cba, margin_of_error) Check if the rate(s) correspond to pattern ("Harmonic Triangle").
Parameters:
rate_cba : float, percent rate of the triangle CBA. expects a negative rate.
margin_of_error : float, percent rate of expected error margin, default 0.05(5%).
Returns: bool
is2Tap(rate_cba, margin_of_error) Check if the rate(s) correspond to pattern ("2Tap", 'Double Top / Bottom').
Parameters:
rate_cba : float, percent rate of the triangle CBA. expects a negative rate.
margin_of_error : float, percent rate of expected error margin, default 0.05(5%).
Returns: bool
is3Tap(rate_edc, rate_cba, margin_of_error) Check if the rate(s) correspond to pattern ("3Tap", "Triple Top / Bottom").
Parameters:
rate_edc : float, percent rate of the triangle EDC. expects a negative rate.
rate_cba : float, percent rate of the triangle CBA. expects a negative rate.
margin_of_error : float, percent rate of expected error margin, default 0.05(5%).
Returns: bool
is4Tap(rate_gfe, rate_edc, rate_cba, margin_of_error) Check if the rate(s) correspond to pattern ("4Tap", "Quadruple Top / Bottom").
Parameters:
rate_gfe : float, percent rate of the triangle GFE. expects a negative rate.
rate_edc : float, percent rate of the triangle EDC. expects a negative rate.
rate_cba : float, percent rate of the triangle CBA. expects a negative rate.
margin_of_error : float, percent rate of expected error margin, default 0.05(5%).
Returns: bool
isABCD(rate_cba, rate_dcb, margin_of_error) Check if the rate(s) correspond to pattern ("AB=CD").
Parameters:
rate_cba : float, percent rate of the triangle CBA. expects a negative rate.
rate_dcb : float, percent rate of the triangle DCB. expects a negative rate.
margin_of_error : float, percent rate of expected error margin, default 0.05(5%).
Returns: bool
isBat(rate_edc, rate_dcb, rate_cba, rate_eda, margin_of_error) Check if the rate(s) correspond to pattern ("Bat").
Parameters:
rate_edc : float, percent rate of the triangle EDC. expects a negative rate.
rate_dcb : float, percent rate of the triangle DCB. expects a negative rate.
rate_cba : float, percent rate of the triangle CBA. expects a negative rate.
rate_eda : float, percent rate of the triangle EDA. expects a negative rate.
margin_of_error : float, percent rate of expected error margin, default 0.05(5%).
Returns: bool
isButterfly(rate_edc, rate_dcb, rate_cba, rate_eda, margin_of_error) Check if the rate(s) correspond to pattern ("Butterfly").
Parameters:
rate_edc : float, percent rate of the triangle EDC. expects a negative rate.
rate_dcb : float, percent rate of the triangle DCB. expects a negative rate.
rate_cba : float, percent rate of the triangle CBA. expects a negative rate.
rate_eda : float, percent rate of the triangle EDA. expects a negative rate.
margin_of_error : float, percent rate of expected error margin, default 0.05(5%).
Returns: bool
isGartley(rate_edc, rate_dcb, rate_cba, rate_eda, margin_of_error) Check if the rate(s) correspond to pattern ("Gartley").
Parameters:
rate_edc : float, percent rate of the triangle EDC. expects a negative rate.
rate_dcb : float, percent rate of the triangle DCB. expects a negative rate.
rate_cba : float, percent rate of the triangle CBA. expects a negative rate.
rate_eda : float, percent rate of the triangle EDA. expects a negative rate.
margin_of_error : float, percent rate of expected error margin, default 0.05(5%).
Returns: bool
isCrab(rate_edc, rate_dcb, rate_cba, rate_eda, margin_of_error) Check if the rate(s) correspond to pattern ("Crab").
Parameters:
rate_edc : float, percent rate of the triangle EDC. expects a negative rate.
rate_dcb : float, percent rate of the triangle DCB. expects a negative rate.
rate_cba : float, percent rate of the triangle CBA. expects a negative rate.
rate_eda : float, percent rate of the triangle EDA. expects a negative rate.
margin_of_error : float, percent rate of expected error margin, default 0.05(5%).
Returns: bool
isShark(rate_edc, rate_dcb, rate_cba, rate_eda, margin_of_error) Check if the rate(s) correspond to pattern ("Shark").
Parameters:
rate_edc : float, percent rate of the triangle EDC. expects a negative rate.
rate_dcb : float, percent rate of the triangle DCB. expects a negative rate.
rate_cba : float, percent rate of the triangle CBA. expects a negative rate.
rate_eda : float, percent rate of the triangle EDA. expects a negative rate.
margin_of_error : float, percent rate of expected error margin, default 0.05(5%).
Returns: bool
is5o(rate_edc, rate_dcb, rate_cba, rate_eda, margin_of_error) Check if the rate(s) correspond to pattern ("5o").
Parameters:
rate_edc : float, percent rate of the triangle EDC. expects a negative rate.
rate_dcb : float, percent rate of the triangle DCB. expects a negative rate.
rate_cba : float, percent rate of the triangle CBA. expects a negative rate.
rate_eda : float, percent rate of the triangle EDA. expects a negative rate.
margin_of_error : float, percent rate of expected error margin, default 0.05(5%).
Returns: bool
isWolfe(rate_edc, rate_dcb, rate_cba, rate_eda, margin_of_error) Check if the rate(s) correspond to pattern ("Wolfe").
Parameters:
rate_edc : float, percent rate of the triangle EDC. expects a negative rate.
rate_dcb : float, percent rate of the triangle DCB. expects a negative rate.
rate_cba : float, percent rate of the triangle CBA. expects a negative rate.
rate_eda : float, percent rate of the triangle EDA. expects a negative rate.
margin_of_error : float, percent rate of expected error margin, default 0.05(5%).
Returns: bool
is3Driver(rate_edc, rate_dcb, rate_cba, rate_eda, margin_of_error) Check if the rate(s) correspond to pattern ("3 Driver").
Parameters:
rate_edc : float, percent rate of the triangle EDC. expects a negative rate.
rate_dcb : float, percent rate of the triangle DCB. expects a negative rate.
rate_cba : float, percent rate of the triangle CBA. expects a negative rate.
rate_eda : float, percent rate of the triangle EDA. expects a negative rate.
margin_of_error : float, percent rate of expected error margin, default 0.05(5%).
Returns: bool
isConTria(rate_edc, rate_dcb, rate_cba, rate_eda, margin_of_error) Check if the rate(s) correspond to pattern ("Contracting Triangle").
Parameters:
rate_edc : float, percent rate of the triangle EDC. expects a negative rate.
rate_dcb : float, percent rate of the triangle DCB. expects a negative rate.
rate_cba : float, percent rate of the triangle CBA. expects a negative rate.
rate_eda : float, percent rate of the triangle EDA. expects a negative rate.
margin_of_error : float, percent rate of expected error margin, default 0.05(5%).
Returns: bool
isExpTria(rate_edc, rate_dcb, rate_cba, rate_eda, margin_of_error) Check if the rate(s) correspond to pattern ("Expanding Triangle").
Parameters:
rate_edc : float, percent rate of the triangle EDC. expects a negative rate.
rate_dcb : float, percent rate of the triangle DCB. expects a negative rate.
rate_cba : float, percent rate of the triangle CBA. expects a negative rate.
rate_eda : float, percent rate of the triangle EDA. expects a negative rate.
margin_of_error : float, percent rate of expected error margin, default 0.05(5%).
Returns: bool
isHnS(rate_fed, rate_feb, rate_edc, rate_dcb, rate_cba, rate_eda, margin_of_error) Check if the rate(s) correspond to pattern ("Head and Shoulders").
Parameters:
rate_fed : float, percent rate of the triangle FED. expects a negative rate.
rate_feb : float, percent rate of the triangle FEB. expects a negative rate.
rate_edc : float, percent rate of the triangle EDC. expects a negative rate.
rate_dcb : float, percent rate of the triangle DCB. expects a negative rate.
rate_cba : float, percent rate of the triangle CBA. expects a negative rate.
rate_eda : float, percent rate of the triangle EDA. expects a negative rate.
margin_of_error : float, percent rate of expected error margin, default 0.05(5%).
Returns: bool
3 EMA + Stochastic RSI + ATR 3ESRA
v0.2a
Coded by Vaida Bogdan
3ESRA consists of a 3 EMA cross + a close above (for longs) the quickest EMA
or below (for shorts). Note that I've deactivated the RSI Cross Over/Under
(you can modify the code and activate it). The strategy also uses a stop loss
that's at 1 ATR distance from the entry price and a take profit that's at
4 times the ATR distance from the entry price.
Harmonic Scanner ProHarmonic Scanner Pro is a more advanced version of the standard Harmonic Scanner . It lets you customize almost every parameter, check for harmonic patterns much further in the past, and detect multiple patterns at once. It's a great tool to see how specific security reacts to harmonic patterns (some stocks are a textbook example of harmonic patterns , others - not really).
Some of it's features:
You can check an unlimited number of the high/low points (the free version only checks the last 5 points). Use the "Number of points to check" option to configure how many points to check.
Configurable error tolerance - you can set how many % the detected formation can differ from the "ideal" formation. (the free version uses the hardcoded 5% value)
Formations displayed on top of each other can be moved using the "Move chart" option. When two or more formations share the same points on the chart, only the topmost is visible. With the "move chart" option enabled (it's enabled by default), we move all those points up/down a bit to make all the lines nicely visible and easy to follow
Each formation uses different color on the chart, so it's easier to follow them
You can change the width of the ZigZag and formation lines
Detects the Gartley , Butterfly , Bat, Alternate Bat , Crab , Deep Crab , and Cypher .
Important: Checking for more than 200 points and displaying the ZigZag pattern + "No formation" labels at the same time might make the script too slow to render and result in a "Script error". When that happens, disable the ZigZag /"No formation" labels or decrease the number of points to check.
To get 7 days of free access to the script, just leave a comment.
Works for different types of commodities:
Works for different intervals:
Some securities work better than others with harmonic patterns:
All Candlestick Patterns - ExportThis is a copy of the built-in All Candlestick Patterns indicator, but with an additional plot for each indicator to support exporting. When exporting, each candlestick pattern will have its own column, with a 1 indicating the candlestick pattern was detected, and 0 indicating it wasn't. The plots are all overlaid, so are they are not useful for viewing, they are only used to generate values to export. This indicator also does not include alerts, so the built-in indicator should be used for everything except exporting.
[TS] S/R TweezersThe Tweezers pattern is a minor trend reversal pattern that consists of two candlesticks with more or less the same high or the same low or some variation thereof. The user can adjust this variation by changing the 'Tweezer Wick Percentage' input.
The Tweezers Bottom pattern generally appears in a downtrend with the first candlestick being a bearish candlestick, followed by a bullish candlestick.
The Tweezers Top pattern generally appears in an uptrend. The first candlestick in this pattern is a bullish candlestick followed by a bearish candlestick.
To further confirm the trend reversal, we've added an Engulfing filter. If this option is enabled, the indicator will only show Tweezer signals that also engulf the previous 1 or 2 candles.
We've also included a S/R Lookback Filter that will search for previous Support/Resistance Zones and only display those Tweezers that are within those zones. The candle lookback period is fully adjustable.
The Support/Resistance zones are based on Swing Points, which length can be adjusted by the user.
The user can also change the width of the S/R zones, by adjusting the input 'S/R Zone ATR Multiplier'
GreenCrypto Swing Trade Indicator - GC02Overview: This is a swing trading Indictor works using support & resistance and market trend, it is designed for all type of markets (crypto, forex, stock etc.) and works on all commonly used timeframes (preferably on 1H, 4H Candles).
How it works:
Core logic behind this indicator is to finding the Support and Resistance, we find the Lower High (LH) and Higher Low (HL) to find the from where the price reversed(bounced back) and also we use a custom logic for figuring out the peak price in the last few candles (based on the input "Strength" ). Based on the multiple previous Support and Resistance (HH, HL, LL LH) we calculate a price level, this price level is used a major a factor for entering the trade. Once we have the price level we check if the current price crosses that price level, if it crossed then we consider that as a long/short entry (based on whether it crosses resistance or support line that we calculated). Once we have pre long/short signals we further filter it based on the market trend to prevent too early/late signals, this trend is calculated based on the value from the input field "Factor". Along with this if we don't see a clear trend we do the filtering by checking how many support or resistance level the price has bounced off.
Stop Loss and Take Profit : We have also added printing SL and TP levels on the chart to make the it easier for everyone to find the SL/TP values. Script calculates the SL value by checking the previous support level for LONG trade and previous resistance level for SHORT trades. Take profit are calculated in 1:1 ratio as of now.
Available Inputs:
Strength : Define the strength of the support resistance that we calculate. The lower value means less number of candles used for calculating the support & resistance and vice versa
Factor : Specify what level of trend to use. Using higher value will result script looking using the larger trend (zoomed out trend) and using lesser value will result in using the short trends
Note: For most of the charts you don’t need to change the default values. However, feel free to try it out.
How to use:
Add the script to the chart and once the indicator is load it will display the "long" and "short" entry points along with the stopLoss and takeProfit points.
How to get access:
Send a DM to us for getting access to the script.
Harmonic ScannerThis script detects harmonic formations: Gartley, Bat, Butterfly, and Crab.
Unlike the other harmonic scanners, it analyzes more than the last five consecutive points. It checks up to 50 last high/low points and tries to find a pattern there. It also labels point D with information on what type of formation it is and if it's a signal to sell or buy.
The default error margin for each formation is 5% (so each point can be up to 5% different than the ideal value defined in the books).
I don't have enough reputation for linking other charts, but check it out with BATS:V (Visa) and BATS:JPM (JPMorgan Chase) to see more formations.
Harmonic PatternsHello Traders,
This is Harmonic Pattern script . I made this script long time ago and now pubished it for the community. it can find & show following patterns:
- Gartley
- Butterfly
- Bat
- Alternate Bat
- Crab
- Deep Crab
- Shark
- Cypher
- Double Top
- Double Bottom
- ABCD
only ABCD patterns is not enabled by default, you can enable if you want.
The script has many features in it, so you have many options. lets see them
ZigZag Period : is the period for zig zag that is used to find harmonic patterns.
Error Rate % : the patterns may not be perfect and we need to use a threshold. with this option you can set error rate
Deep Search: if you enable this option then the script check combination with old zigzag points. an example is under the explanation part
Pattern Prediction : if you set this option then while price is moving the script checks the possible next patterns that can be possible (shows first possible one). an example is under the explanation part
Show ZigZag: you have option to see zigzag
Show Pattern Names: you have option to see Pattern names
Remove Old Pattern Names : old found patterns can stay on the chart or you have option to delete from the chart by this option
Show Harmonics: you have option to show patterns
Show Targets: you have option to see the target and stop-loss level by each harmonic
Show Statistics: you can see the statictics about harmonic patterns on current chart
Show Full Statistics: you can see the statictics about harmonic patterns on current chart in details
"Stop-loss ATR Len" and "Stop-loss ATR Mult" is used to calculate stop-loss levels
and many options for visualization and alerts...
The scripts works dynamically in real time, it means it may find different patterns on each candles. if it finds a new one in same direction then old one becomes invalid, you should check the last one.
Lets see some examples:
it changes the colors if price reached the target or stop-loss. blue => reached target, black => stop-loss, and if color was not changed it means it found another harmonic pattern.
if it finds a harmonic pattern then it show entrty level, cancelation level of the pattern, target 1 and target 2
and if price reaches entrty level then it shows targets and stop-loss levels
as written above, t has ability to predict patterns if you enable this option:
Deep search is used to find patterns by some old zigzag levels as seen in following screenshot:
it can show full statistics if you enable it in the options:
The source code is hidden but it's free script. so like it/favorite this script, apply it to your chart and start using it ;)
Special thanks to my friend @gornidah who helped while developing the script!
Enjoy!
[TrustedSignals] Doji ScalperTrustedSignals Dojji Scalper is our most basic trading algorithm. It is based on Candle Patterns that show potential market reversal points.
The script has 3 different types of signals, which can be individually turned on and off:
- Doji signals, based entirely on the Doji candle pattern and 2 Strong and Weak candle reversal patters
As a bonus, we have included RSI based Support and Resistance bands that, if used correctly can further confirm all the entry signals
All chart signals can be set up as live alerts!
Fractal Trend Trading System [DW]This is an advanced utility that uses fractal dimension and trend information to generate useful insights about price activity and potential trade signals.
In this script, my Advanced FDI algorithm is used to estimate the fractal dimension of the dataset over a user defined period.
Fractal dimension, unlike spatial or topological dimension, measures how complexity or detail in an "object" changes as its unit of measurement changes, rather than the number of axes it occupies.
Many forms of time series data (seismic data, ECG data, financial data, etc.) have been theoretically shown to have limited fractal properties.
Consequently, we can estimate the fractal dimension from this data to get an approximate measure of how rough or convoluted the data stream is.
Financial data's fractal dimension is limited to between 1 and 2, so it can also be used to roughly approximate the Hurst Exponent by the relationship H = 2 - D.
When D=1.5, data statistically behaves like a random walk. D above 1.5 can be considered more rough or "mean reverting" due to the increase in complexity of the series.
D below 1.5 can be considered more prone to trending due to the decrease in complexity of the series.
In this script, you are given the option to apply my Band Shelf EQ algorithm to the dataset before estimating dimension.
This enables you to transform your data and observe how its newly measured complexity changes the outputs.
Whether you want to give emphasis to some frequencies, isolate specific bands, or completely alter the shape of your waveform, EQ filtration makes for an interesting experience.
The default EQ preset in this script removes the low shelf, then attenuates low end and high end oscillations.
The dominant cyclical components (bands 3 - 5 on default settings) are passed at 100%, keeping emphasis on 8 to 64 sample per cycle oscillations.
The estimated dimension is then used to calculate the High Dimension Zone and the Error Bands.
Both of these components are great for analyzing trends and for estimating support and resistance values.
The High Dimension Zone is composed of a high line, low line, and midline that update their values when D is at or above the user defined zone activation threshold.
The zone is then averaged over a user defined amount of updates and zone width is multiplied by a user defined value.
The Error Bands are composed of a high, low, and middle band that are calculated using an error adjusted adaptive filter algorithm that utilizes dimension as the smoothing constant modulator.
The basis filter for the error bands has two calculation types built in:
-> MA - Calculates the filters as adaptive moving averages modulated by D.
-> WAP - Calculates the filters as adaptive weighted average prices modulated by D.
The WAP starting point can be based on the High Dimension Zone being moved or a user defined interval.
You can also define the WAP's minimum and maximum periods for additional control of the initial and decayed sensitivity states.
The alpha (smoothing constant) modulator can be fine tuned using the designated dimension thresholds.
When D is at or below the low dimension threshold, the filter is most responsive, and vice-versa for the high dimension threshold.
Alpha is then multiplied by a user defined amount for additional control of sensitivity.
Band width is then multiplied by a user defined value.
A Hull transformation can be optionally performed on the zone averaging and band filter algorithms as well, which will alter the frequency and phase responses at the cost of some overshoot.
This transformation is the same as a typical Hull equation, but with custom filters being used instead of WMA.
The calculated outputs are then used to gauge the trend for signal and color scheme calculations.
First, a dominant trend indication is selected from its designated dropdown tab.
The available built in indications to choose from are:
-> Band Trend (Outer) - Detects band breakouts and saves their direction to gauge trend.
-> Band Trend (Median) - Uses disparity between source and the band median to gauge trend.
-> Zone Trend (Expansion) - Detects when the high fractal zone expands and saves its direction to gauge trend.
-> Zone Trend (Outer Levels) - Detects zone breakouts and saves their direction to gauge trend.
-> Zone Trend (Median) - Uses disparity between source and the zone median to gauge trend.
Then the trend output is optionally filtered before triggering signals.
There are multiple trend filtration options built into this script that can be used individually or in unison:
-> Filter Trend With High Fractal Zone - Filters the trend using the specified zone level or combination of levels with either disparity or crossover conditions.
There is a set of options for bullish and bearish trends.
-> Filter Trend With Error Bands - Filters the trend using the specified band level or combination of levels with either disparity or crossover conditions.
There is a set of options for bullish and bearish trends.
-> Filter Trend With Band - Zone Disparity Condition - Filters the trend using the specified band level, zone level, and disparity direction.
There is a set of options for bullish and bearish trends.
-> Filter By Zone That Moves With The Trend - Filters the specified trend by detecting when the high fractal zone’s direction correlates.
-> Filter By Bands That Move With The Trend - Filters the specified trend by detecting when the error bands’ direction correlates.
-> Filter Using Wave Confirmation - Filters the specified trend by detecting when source is in a correlating wave with user defined length.
You can also choose separate lengths for bullish and bearish trends.
-> Filter By Bars With Decreasing Dimension - Filters the specified trend by detecting when fractal dimension is decreasing, suggesting source is approaching more linear movement.
The filtered trend output is then used to generate entry and exit signals.
There are multiple options included to fine tune how these signals behave.
For entries, you have the following options built in:
-> Limit Entry Dimension - Limits the range of dimensional values that are acceptable for entry with user defined thresholds.
This can be incredibly useful for filtering out entries taken when price is moving in a more complex pattern,
or when price is approaching a peak and you’re a little late to the party.
-> Enable Position Increase Signals - Enables more entry signals to fire up to a user defined number of times when a position is active.
This is helpful for those who incrementally increase their positions, or for those who want to see additional signals as reference.
-> Limit Number Of Consecutive Trades - Limits the number of consecutive trades that can be opened in a single direction to a user defined maximum.
This is especially useful for markets that only trend for brief durations.
By limiting the amount of trades you take in one direction, you have more control over your market exposure.
There is a set of these options for both bullish and bearish entries.
For exits, you have the following options built in:
-> Include Exit Signals From High Fractal Zone - Enables exit signals generated from either crossover or disparity conditions between price and a specified zone level.
-> Include Exit Signals From Error Bands - Enables exit signals generated from either crossover or disparity conditions between price and a specified zone level.
-> Include Inactive Trend Output For Exits - Triggers exit signals when the filtered trend output is an inactive value.
-> Dimension Target Exit Method - Triggers exit signals based on fractal dimension hitting a user defined threshold.
You can either choose for the exit to trigger instantly, or after dimension reverts from the target by a user specified amount.
-> Exit At Maximum Entry Dimension - Triggers exit signals when dimension exceeds the maximum entry limit.
-> Number Of Signals Required For 100% Exit - Controls the number of exit signals required to close the position.
You can also choose whether or not to include partial exits.
Enabling them will fire a partial signal when an exit occurs, but the position is not 100% closed.
Of course, there is a set of these options for bullish and bearish exits.
In my opinion, no system is complete without some sort of risk management protocol in place.
So in this script, bullish and bearish trades come equipped with optional protective SL and TP levels with signals.
The levels can be fixed or trailing, and are calculated with a user defined scale.
The available scales for SL and TP distances are ticks, pips, points, % of price, ATR, band range, zone range, or absolute numerical value.
Now what if you have some awesome signals of your own that you’d like to use in conjunction with this script?
Well good news. You can!
In addition to all of the customizable features built into the script, you can integrate your own signals into the system using the external data inputs and linking your script.
This adds a whole new layer of customization to the system.
With external signals, you can use your own custom dominant trend indication, filter the dominant trend, and trigger exits and protective stops using custom signals.
The signal input is an integer format. 1=Bull Signal, -1=Bear Signal, 2=Bull Exit, -2=Bear Exit, 3=Bull SL Hit, -3=Bear SL Hit, 4=Bull TP Hit, -4=Bear TP Hit.
You can also use the external input as a custom source value for either dimension or global sources to further tailor the system to your liking.
The color scheme in this script utilizes two custom gradients that can be chosen for bar and background colors:
-> Trend (Dominant or Filtered) - A polarized gradient that shows green scaled values for bullish trend and red scaled values for bearish trend.
The colors are brighter and more vibrant as perceived trend strength increases.
-> Dimension - A thermal gradient that shows cooler colors when dimension is higher, and hotter colors when dimension is lower.
Both color schemes are dependent on the designated dimension thresholds.
The script comes equipped with alerts for entries, additional entries, exits, partial exits, and protective stops so you can automate more and stare at your charts less.
And lastly, the script comes equipped with additional external outputs to further your analysis:
-> Entry And Exit Signals - Outputs in the same format as the external signal input with these additions: 5=Bull Increase, -5=Bear Increase, 6=Bull Reduce, -6=Bear Reduce.
You can use these to send to other scripts, including strategy types so you can backtest your performance on TV’s engine.
-> Dominant Trend - Outputs 1 for bullish and -1 for bearish. Can be used to send trend signals to another script.
I designed this tool with individuality in mind.
Every trader has a different situation. We trade on different schedules, markets, perspectives, etc.
Analytical systems of basically any type are very seldom (if ever) “one size fits all” and usually require a fair amount of modification to achieve desirable results.
That’s why this system is so freely customizable.
Your system should be flexible enough to be tailored to your analytical style, not the other way around.
When a system is limited in what you can control, it limits your experience, analytical potential, and possibly even profitability.
This is not your typical pre-set system. If you're looking for just another "buy, sell" script that requires minimal thought, look elsewhere.
If you’re ready to dive into a powerful technical system that allows you to tailor the experience to your style, welcome!
-----------------------------------------------------------------------------------------------------------------------------------------------------------------
This is a premium script, and access is granted on an invite-only basis.
To gain access, get a copy of the system overview, or for additional inquiries, send me a direct message.
I look forward to hearing from you!
-----------------------------------------------------------------------------------------------------------------------------------------------------------------
General Disclaimer:
Trading stocks, futures, Forex, options, ETFs, cryptocurrencies or any other financial instrument has large potential rewards, but also large potential risk.
You must be aware of the risks and be willing to accept them in order to invest in stocks, futures, Forex, options, ETFs or cryptocurrencies.
Don’t trade with money you can’t afford to lose.
This is neither a solicitation nor an offer to Buy/Sell stocks, futures, Forex, options, ETFs, cryptocurrencies or any other financial instrument.
No representation is being made that any account will or is likely to achieve profits or losses of any kind.
The past performance of any trading system or methodology is not necessarily indicative of future results.
Candlestick Pattern FinderThis script identifies common candlestick patterns and marks them with a tool-tip on the chart. It is a compilation of Tradingview's built-in candlestick finding scripts so it uses the same rules defined by Tradingview to identify the patterns. Instead of using a separate indicator for each candlestick pattern, you can use this script to find all the candlestick patterns with a single indicator.
By default, the script does not mark any of the detected patterns on the chart. You will have to open the indicator settings and enable the patterns you would like to see on the chart. There are also three tick-boxes that let you to enable/disable all the selected bearish/bullish/neutral patterns at once, i.e. if you would like to only see bearish patterns, you can disable all the bullish and neutral patterns at once with the corresponding tick boxes. When you enable bullish patterns again, the script will show your selection of bullish patterns again on the chart.
When you hover on the tool-tips with your cursor, a short description about the pattern will be displayed.
Candlestick Pattern Detector - Aitch-TThis script detects the following candlestick patterns:
Bullish Patterns:
- Normal 3 Bar Fractal
- Enhanced 3 Bar Fractal
- Engulfing
- Harami ( Inside bar )
- Bullrami (Altenate Bull Harami)
Bearish Patterns:
- Normal 3 Bar Fractal
- Enhanced 3 Bar Fractal
- Engulfing
- Harami ( Inside bar )
- Bearami (Alternate Bear Harami)
- Shooting Star
How it works:
- When you add the script to your chart, green and red dots will appear at the top and the bottom of the chart.
- Red dots at the top of the chart point out the candles that have completed a bearish pattern .
- Green dots at the bottom of the chart point out the candles that have completed a bullish pattern .
How to use:
Use it in conjunction with other analysis tools ( Fibonacci Retracements, Histogram, Willy, RSI , volume , etc) to determine high probability levels.
Candlestick PatternsCandlestick Patterns
- Candlesticks are graphical representations of price movements for a given period of time.
- There are candlestick patterns that try to predict the final direction, caused by pressure between buyers and sellers.
As a general recommendation, use the candlestick patterns in the same direction of the current trend (continuations),
for reverse patterns we must expect the price to be over extended, for example,
that it is the highest or lowest value of (20-50) periods,
or that the RSI is overbought or oversold (14-50),
or that the price is far from its standard deviation.
- This indicator allows you to view more than 20 different patterns, some of them:
Doji
Engulfing
Hammer
Shooting Star
Inverted Hammer
Hanging Man
Morning Star
Evening Star
etc...
- The indicator allows displaying the full name of the pattern
- It allows you to view the labels at the top of the chart, to avoid this affecting the technical analysis
Candle Patterns Strategy - 2New risk management system: order entry, moving stop loss to breakeven + moving average filter (SMA)
Candlestick Patterns Strategy (revisited)This strategy is used as a benchmark to see how it compares with other strategies posted by me recently. In all, the below collection of candlestick patterns appears to be one of the best among the ones that can be found here, imho.
