Astro: Time-Degree Trend Lines [invincible3]Astro-Gann Time-Degree Trend Lines – Invincible3
Astro-Gann Time-Degree Trend Lines is a range-based financial astrology and Gann timing tool designed to project planetary motion into price space.
Instead of plotting ordinary planetary positions, this indicator converts planetary movement into price-degree trend lines using a selected anchor price, anchor time, end time, user-defined planetary starting degrees, a motion harmonic multiplier, and a custom price-per-degree scale.
The concept is based on the Gann principle that time, price, and degrees can be harmonically related. Each planet’s movement over the selected range is converted into price movement, allowing traders to study planetary speed, time cycles, price vibration, and harmonic market geometry directly on the chart.
The indicator also includes a Gann-style aspect table that compares planet-to-planet angular relationships at the end of the selected range using each planet’s manually entered starting degree. This makes the aspect logic more meaningful because planets no longer begin from a common zero point. Each planet can start from its own real zodiac degree, ephemeris-based value, or symbolic Gann degree.
This tool is especially useful for traders who apply W.D. Gann methods, planetary time cycles, price-time squaring, astro-harmonics, Square of 9 logic, 360° degree geometry, and financial astrology to identify possible zones of trend continuation, support, resistance, vibration, or reversal timing.
What This Indicator Does
The indicator starts from a selected anchor price and anchor time.
Each planet also has a user-defined starting degree at the anchor. From that point, the script calculates how many degrees each planet moves during the selected date range, adds that motion to the planet’s starting degree, and then converts the resulting degree value into a projected price level.
The projection model is:
Planetary Motion = Days × Average Daily Motion × Motion Harmonic Multiplier
Line Degree = Starting Degree + Planetary Motion
Projected Price = Anchor Price ± (Line Degree × Points Per Degree)
This means the starting degree directly affects the trend-line position.
For example, if the Sun starts at 4°, moves 30°, and the selected scale is 10 points per degree, then:
Line Degree = 4° + 30° = 34°
Projected Price = Anchor Price ± 340 points
So the line does not only represent planetary movement from zero. It represents the full start-degree-adjusted Gann line degree.
Core Concept
This is not a standard astronomical aspect indicator. It is a Gann-style time-degree projection tool.
The purpose is to study:
How many degrees each planet moves during a selected market range.
How planetary motion can be translated into price.
How each planet’s starting degree changes the projected line position.
Which planets produce stronger or weaker price-time slopes.
Where planetary degree projections align with price structure.
Which planet pairs form Gann/astro harmonic relationships at the end of the range.
This makes the indicator useful for analyzing market vibration, planetary speed relationships, price-time geometry, harmonic projection, and range-based astro-Gann timing.
Key Features
Range-Based Astro-Gann Projection
Select a custom time range using:
Anchor Time
End Time
Anchor Price
The indicator calculates planetary movement across this exact range and projects it onto the price chart.
This allows traders to study planetary motion from an important market event such as:
Major swing high
Major swing low
Breakout point
Crash low
All-time high
Cycle start
First trading date
Gann anniversary date
Important planetary event
Major economic or market cycle date
The selected range becomes the measurement window for planetary movement and Gann degree projection.
User-Defined Starting Degrees
Each planet has a manual starting degree input.
This allows traders to enter the actual zodiac degree or symbolic Gann degree of each planet at the anchor date.
The starting degree affects:
The plotted planetary trend-line position
The projected price level
The end label
The final line degree
The aspect-table end longitude
This correction is important because each planet no longer starts from 0°. Each body can begin from its own real, ephemeris-based, or symbolic starting degree.
For price projection, the indicator uses:
Line Degree = Starting Degree + Planetary Motion
For aspect calculations, the indicator uses:
End Longitude = Starting Degree + Signed Planetary Motion
Planetary Time-Degree Trend Lines
The indicator plots planetary motion lines for:
☉ Sun
☾ Moon
☿ Mercury
♀ Venus
♂ Mars
♃ Jupiter
♄ Saturn
♅ Uranus
♆ Neptune
♇ Pluto
☊ Lunar Node
Each planet has:
Its own average daily motion
Its own starting degree
Its own projected line degree
Its own color setting
Its own visibility toggle
The final trend-line position is based on the planet’s starting degree plus its movement over the selected range.
Uptrend and Downtrend Projection
The indicator can plot:
Upward planetary projection lines
Downward planetary projection lines
Upward lines project planetary degree movement above the anchor price.
Downward lines project planetary degree movement below the anchor price.
This allows traders to study both bullish and bearish price-time pathways from the same anchor.
For example:
Up projection = Anchor Price + Line Degree × Points Per Degree
Down projection = Anchor Price - Line Degree × Points Per Degree
This gives a balanced way to study both expansion and contraction from a selected market point.
Points Per Degree Scaling
The user can define how many price points represent one planetary degree.
Examples:
1 point per degree
10 points per degree
100 points per degree
Custom market-specific scaling
This is useful because every market has a different vibration.
Gold, Bitcoin, forex pairs, stocks, commodities, and indices may require different degree-to-price scaling.
The purpose is to find a scale where planetary degree projections align meaningfully with market structure, swing points, or harmonic price zones.
Motion Harmonic Multiplier
The motion harmonic multiplier can be used to increase or decrease the speed of planetary projection.
Examples:
1x = normal planetary motion
2x = double-speed harmonic
0.5x = half-speed harmonic
This can be useful for traders who study:
Harmonic repetition
Accelerated cycles
Compressed planetary timing
Higher-frequency market vibration
Fractional planetary movement
The motion harmonic multiplier changes the planetary movement component of the line.
It affects the slope and speed of the planetary projection. It should be understood as a speed or cycle multiplier, not as a 360° price octave shift.
Gann Aspect Table
The indicator includes a compact aspect table that compares planet-to-planet angular relationships at the end of the selected range.
The table uses each planet’s starting degree and signed planetary motion:
End Longitude = Starting Degree + Signed Planetary Motion
Then it calculates the angular separation between planet pairs and finds the nearest Gann/astro aspect.
Supported aspect angles include:
0° Conjunction
30° Semi-sextile
45° Semi-square
60° Sextile
72° Quintile
90° Square
120° Trine
135° Sesquiquadrate
144° Biquintile / Gann harmonic
150° Quincunx
180° Opposition
The table displays:
Planet pair
Nearest aspect
Angular delta at range end
Orb from exact aspect
This helps identify which planet pairs are in close harmonic relationship at the end of the selected range.
Aspect Interpretation for Gann Traders
In financial astrology and Gann analysis, aspects are not used only as traditional astrology signals. They are also treated as geometric divisions of the 360° circle.
Important divisions include:
45° and 90° for square pressure and market action
60° and 120° for smoother harmonic flow
72° and 144° for fifth-harmonic and pentagonal geometry
180° for opposition, polarity, and possible culmination
30° and 150° for adjustment zones
When a planet pair forms a tight orb near one of these angles, it may indicate a time window where market rhythm, volatility, or direction can shift.
The table is not meant to be used as a standalone signal. It is designed to provide astro-Gann confluence with price structure, swing points, trendlines, Fibonacci levels, cycle dates, and market context.
How to Use
1. Choose an Important Market Anchor Point
Select a meaningful market point such as:
Major swing high
Major swing low
Breakout level
Crash low
All-time high
All-time low
First trading date
Cycle start
Gann anniversary date
This anchor becomes the origin point for the projection.
2. Set the Anchor Price
Enter the price level from which the planetary degree lines will begin.
This is usually the price of the selected swing high, swing low, breakout, or cycle point.
3. Set the Anchor Time and End Time
Choose the start and end dates of the range.
The indicator calculates planetary movement across this selected time window.
The range defines the time component of the Astro-Gann projection.
4. Enter Starting Degrees for Each Planet
Enter the starting degree for each planet at the anchor date.
These can be:
Actual zodiac degrees from an ephemeris
Geocentric planetary degrees
Heliocentric planetary degrees
Symbolic Gann degrees
Custom cycle degrees chosen by the trader
The starting degree affects both the trend-line position and the aspect-table calculation.
5. Adjust Points Per Degree
Increase or decrease the price-per-degree value until the projected planetary lines match the market’s vibration.
Different markets may require different scales.
For example:
Gold may respond better to one scale.
Bitcoin may require a larger scale.
Forex may require a smaller scale.
Stocks and indices may need symbol-specific calibration.
6. Adjust the Motion Harmonic Multiplier
Use the motion harmonic multiplier to test faster or slower planetary projection rhythms.
For example:
1x = normal planetary speed
2x = double-speed projection
0.5x = half-speed projection
This is useful when studying compressed cycles, expanded cycles, or harmonic repetitions of planetary motion.
7. Enable the Planets You Want to Study
Enable or disable planets depending on your trading timeframe.
General use:
Moon, Mercury, Venus = faster short-term timing
Sun and Mars = intermediate timing
Jupiter and Saturn = larger cycle structure
Uranus, Neptune, Pluto = macro or long-term harmonic background
Node = long-cycle timing reference in financial astrology
8. Use the Aspect Table
Look for tight orbs between planet pairs near important Gann aspects such as:
45°
60°
72°
90°
120°
135°
144°
150°
180°
The tighter the orb, the closer the pair is to an exact harmonic relationship at the end of the selected range.
Use this as timing confluence, not as a mechanical buy/sell signal.
Practical Trading Applications
This indicator can be used to study:
Price-time squaring
Planetary degree projection
Market vibration
Time-cycle completion
Harmonic resistance and support zones
Planetary speed-based trend slopes
Start-degree-adjusted planetary projection
Possible reversal windows
Range-based astro-Gann confluence
Planet-to-planet harmonic relationships
It is best used together with normal market structure tools such as:
Swing highs and lows
Trendlines
Fibonacci levels
Support and resistance
Volume
Momentum indicators
Cycle dates
Seasonality
Volatility zones
The strongest use case is when planetary lines, motion harmonics, aspect-table harmonics, and technical market structure all point to the same zone.
Important Notes
This indicator uses average daily planetary motion, not a full astronomical ephemeris engine.
The starting degrees are entered manually by the user. For more accurate astrology-based analysis, users should obtain planetary degrees from an ephemeris and enter them into the starting degree fields.
The starting degrees affect both:
Visual projection lines
Aspect-table calculations
This makes the tool more consistent with range-based Astro-Gann analysis.
The Lunar Node is commonly treated as retrograde in zodiac motion. For price-line projection, absolute motion may be used for clean visual direction, while aspect logic respects signed motion.
Because this is a Gann-style projection tool, the purpose is not to predict with certainty. The purpose is to map possible price-time harmonics and observe where market structure reacts around those projected levels.
Known Limitations
Planetary positions are based on average motion, not high-precision ephemeris calculations.
Manual starting degrees are required for meaningful projection and aspect-table results.
The indicator does not automatically fetch real-time planetary longitude.
The motion harmonic multiplier changes projection speed, not a 360° price octave.
Results should be treated as analytical confluence, not standalone trade signals.
Best Use Case
This tool is best suited for traders who already use or are studying:
W.D. Gann methods
Financial astrology
Planetary price-time projection
Square of 9 logic
360° degree geometry
Astro-cycle timing
Harmonic market geometry
Planetary speed relationships
Price-time squaring
It is designed for traders who want to visually connect planetary motion, starting degrees, time range, and price movement directly on the chart.
Summary
Astro-Gann Time-Degree Trend Lines – Invincible3 converts planetary motion into price-degree projections using a selected market range.
The corrected logic combines:
Starting Degree
Planetary Motion
Motion Harmonic Multiplier
Price-per-degree scaling
This creates a practical Astro-Gann projection model where each planet has its own degree origin, its own movement, and its own projected price path.
The result is a charting tool for studying planetary price-time geometry, market vibration, harmonic resistance/support, and possible reversal timing.
Disclaimer
This indicator is for educational and analytical purposes only. It does not provide financial advice or guaranteed market predictions. Always combine astro-Gann analysis with risk management, market structure, and independent trading judgment. Indicator
Planetary Retrograde Periods█ PLANETARY RETROGRADE PERIODS
Visualize when planets appear to move backward through the zodiac. This indicator detects and displays retrograde motion for all 8 planets that exhibit apparent retrograde motion from Earth's perspective: Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune, and Pluto.
Powered by the BlueprintResearch lib_ephemeris library.
█ FEATURES
• 8 Planets Supported — Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune, and Pluto
• Two-Phase Visualization — Distinguishes first half (speed increasing in retrograde direction) from second half (speed decreasing toward direct motion) with different transparency levels
• Future Projections — Projects upcoming retrograde periods up to 500 bars ahead on any timeframe
• Station Markers — Clear labels for Station Retrograde (℞), Midpoint (½), and Station Direct (D)
• Timezone-Aware Labels — Future date/time labels display in your selected timezone
• Alert Conditions — Set alerts for station retrograde, station direct, or any station point
• Per-Planet Colors — Customize colors for each planet individually
• Speed-Based Detection — More accurate than longitude-based methods
█ HOW TO USE
1. Select a Planet — Choose which planet to track from the dropdown (Mercury through Pluto)
2. Enable Two-Phase Display — Toggle "Show Retrograde Halves" to see first half vs. second half shading
3. Configure Future Projections — Set how many bars ahead to scan (1-500) and enable/disable date labels
4. Set Your Timezone — Choose your timezone for accurate future date/time display
5. Customize Colors — Adjust planet colors, transparency levels, and label text color to match your chart theme
6. Create Alerts — Use PulseWire's alert system with the built-in conditions for station points
█ UNDERSTANDING THE DISPLAY
Background Colors:
• First Half of the Planet’s retrograde (lighter shade)
• Second Half of the Planet’s retrograde period (darker shade)
Future Projection Lines:
• ℞ (Station Retrograde) — Yellow dotted line marking when the planet will station retrograde
• ½ (Midpoint) — Shorter line in planet color marking the halfway point of the retrograde period
• D (Station Direct) — Green dotted line marking when the planet will station direct
Labels:
• Top label shows planet symbol and station type
• Bottom label shows projected date and time (optional)
█ ACCURACY
This indicator uses speed-based detection
Timing Accuracy:
• All planets (Mercury through Pluto): Within hours to ±1 day
• Future projections maintain accuracy up to 500 bars on any timeframe
• Spot tested on Daily and Weekly charts with excellent results
For Critical Applications:
Cross-reference with professional ephemeris tools such as JPL Horizons or Swiss Ephemeris for mission-critical timing.
█ TECHNICAL DETAILS
Theory: VSOP87 (Mercury through Neptune), Meeus algorithms (Pluto)
█ REFERENCES
• Meeus, Jean. "Astronomical Algorithms" (2nd Edition, 1998)
• Bretagnon & Francou. "VSOP87 Solutions" — Astronomy and Astrophysics 202 (1988)
Indicator
lib_ephemeris █ PLANETARY EPHEMERIS MASTER LIBRARY
Unified API for calculating planetary positions. Import this single library to access all 11 celestial bodies: Sun, Moon, Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune, and Pluto.
Theory: VSOP87 (planets), ELP2000-82 (Moon), Meeus (Pluto)
═══════════════════════════════════════════════════════════════
█ QUICK START
//@version=6
indicator("Planetary Ephemeris Demo")
import BlueprintResearch/lib_ephemeris/1 as eph
// Get all planets
sun = eph.string_to_planet("Sun")
moon = eph.string_to_planet("Moon")
mercury = eph.string_to_planet("Mercury")
venus = eph.string_to_planet("Venus")
mars = eph.string_to_planet("Mars")
jupiter = eph.string_to_planet("Jupiter")
saturn = eph.string_to_planet("Saturn")
uranus = eph.string_to_planet("Uranus")
neptune = eph.string_to_planet("Neptune")
pluto = eph.string_to_planet("Pluto")
// Get longitude for each planet (geocentric)
sun_lon = eph.get_longitude(sun, time, true)
moon_lon = eph.get_longitude(moon, time, true)
mercury_lon = eph.get_longitude(mercury, time, true)
venus_lon = eph.get_longitude(venus, time, true)
mars_lon = eph.get_longitude(mars, time, true)
jupiter_lon = eph.get_longitude(jupiter, time, true)
saturn_lon = eph.get_longitude(saturn, time, true)
uranus_lon = eph.get_longitude(uranus, time, true)
neptune_lon = eph.get_longitude(neptune, time, true)
pluto_lon = eph.get_longitude(pluto, time, true)
// Plot all planets
plot(sun_lon, "Sun", color.yellow)
plot(moon_lon, "Moon", color.silver)
plot(mercury_lon, "Mercury", color.orange)
plot(venus_lon, "Venus", color.green)
plot(mars_lon, "Mars", color.red)
plot(jupiter_lon, "Jupiter", color.purple)
plot(saturn_lon, "Saturn", color.olive)
plot(uranus_lon, "Uranus", color.aqua)
plot(neptune_lon, "Neptune", color.blue)
plot(pluto_lon, "Pluto", color.gray)
═══════════════════════════════════════════════════════════════
█ AVAILABLE FUNCTIONS
Core Data Access:
• string_to_planet(string) → Planet enum
• get_longitude(Planet, time, preferGeo) → degrees [0, 360)
• get_declination(Planet, time) → degrees
• get_speed(Planet, time) → degrees/day
• is_retrograde(Planet, time) → true/false
Planetary Averages:
• get_avg6_geo_lon(time) → 6 outer planets average
• get_avg6_helio_lon(time)
• get_avg8_geo_lon(time) → 8 classical planets average
• get_avg8_helio_lon(time)
Utility:
• normalizeLongitude(lon) → normalize to [0, 360)
═══════════════════════════════════════════════════════════════
█ SUPPORTED PLANET STRINGS
Works with symbols or plain names (case-insensitive):
• "☉︎ Sun" or "Sun"
• "☽︎ Moon" or "Moon"
• "☿ Mercury" or "Mercury"
• "♀ Venus" or "Venus"
• "🜨 Earth" or "Earth"
• "♂ Mars" or "Mars"
• "♃ Jupiter" or "Jupiter"
• "♄ Saturn" or "Saturn"
• "⛢ Uranus" or "Uranus"
• "♆ Neptune" or "Neptune"
• "♇ Pluto" or "Pluto"
═══════════════════════════════════════════════════════════════
█ COORDINATE SYSTEMS
Geocentric: Positions relative to Earth (default for Sun/Moon)
Heliocentric: Positions relative to the Sun
Use the preferGeo parameter in get_longitude():
• true = geocentric
• false = heliocentric
Sun and Moon always return geocentric (heliocentric not applicable).
═══════════════════════════════════════════════════════════════
█ FUTURE PROJECTIONS
Project planetary positions into the future using polylines:
import BlueprintResearch/lib_vsop_core/1 as core
// Get future timestamp (250 bars ahead)
future_time = core.get_future_time(time, 250)
// Calculate future position
future_lon = eph.get_longitude(mars, future_time, true)
Use with polyline.new() to draw projected paths on your chart. See the commented showcase code in this library's source for a complete 250-bar projection example.
═══════════════════════════════════════════════════════════════
█ OPEN SOURCE
This library is part of an open-source planetary ephemeris project.
Free to use with attribution. MIT License.
═══════════════════════════════════════════════════════════════
█ REFERENCES
• Meeus, Jean. "Astronomical Algorithms" (2nd Ed., 1998)
• Bretagnon & Francou. "VSOP87 Solutions" (1988)
• Chapront-Touzé & Chapront. "ELP2000-82" (1983)
═══════════════════════════════════════════════════════════════
© 2025 BlueprintResearch (Javonnii) • MIT License
@version=6
normalizeLongitude(lon)
Normalizes any longitude value to the range [0, 360) degrees.
Parameters:
lon (float) : (float) Longitude in degrees (can be any value, including negative or >360).
Returns: (float) Normalized longitude in range [0, 360).
string_to_planet(planetStr)
Converts a planet string identifier to Planet enum value.
Parameters:
planetStr (string) : (string) Planet name (case-insensitive). Supports formats: "Sun", "☉︎ Sun", "sun", "SUN"
Returns: (Planet) Corresponding Planet enum. Returns Planet.Sun if string not recognized.
@note Supported planet strings: Sun, Moon, Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune, Pluto
get_longitude(p, t, preferGeo)
Returns planetary longitude with automatic coordinate system selection.
Parameters:
p (series Planet) : (Planet) Planet to query.
t (float) : (float) Unix timestamp in milliseconds (use built-in 'time' variable).
preferGeo (bool) : (bool) If true, return geocentric; if false, return heliocentric.
Returns: (float) Longitude in degrees, normalized to range [0, 360).
@note Sun and Moon always return geocentric regardless of preference (heliocentric not applicable).
get_declination(p, t)
Returns planetary geocentric equatorial declination.
Parameters:
p (series Planet) : (Planet) Planet to query.
t (float) : (float) Unix timestamp in milliseconds (use built-in 'time' variable).
Returns: (float) Geocentric declination in degrees, range where positive is north.
@note Declination is always geocentric (no heliocentric equivalent in library).
get_speed(p, t)
Returns planetary geocentric longitude speed (rate of change).
Parameters:
p (series Planet) : (Planet) Planet to query.
t (float) : (float) Unix timestamp in milliseconds (use built-in 'time' variable).
Returns: (float) Geocentric longitude speed in degrees per day. Negative values indicate retrograde motion. Returns na for Moon.
@note Speed is always geocentric (no heliocentric equivalent in library). Moon speed calculation not implemented.
get_avg6_geo_lon(t)
get_avg6_geo_lon
@description Returns the arithmetic average of the geocentric longitudes for the six outer planets: Mars, Jupiter, Saturn, Uranus, Neptune, and Pluto.
Parameters:
t (float) : (float) Time in Unix timestamp (milliseconds).
Returns: (float) Average geocentric longitude of the six outer planets in degrees, range [0, 360).
get_avg6_helio_lon(t)
get_avg6_helio_lon
@description Returns the arithmetic average of the heliocentric longitudes for the six outer planets: Mars, Jupiter, Saturn, Uranus, Neptune, and Pluto.
Parameters:
t (float) : (float) Time in Unix timestamp (milliseconds).
Returns: (float) Average heliocentric longitude of the six outer planets in degrees, range [0, 360).
get_avg8_geo_lon(t)
get_avg8_geo_lon
@description Returns the arithmetic average of the geocentric longitudes for all eight classical planets: Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune, and Pluto.
Parameters:
t (float) : (float) Time in Unix timestamp (milliseconds).
Returns: (float) Average geocentric longitude of all eight classical planets in degrees, range [0, 360).
get_avg8_helio_lon(t)
get_avg8_helio_lon
@description Returns the arithmetic average of the heliocentric longitudes for all eight classical planets: Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune, and Pluto.
Parameters:
t (float) : (float) Time in Unix timestamp (milliseconds).
Returns: (float) Average heliocentric longitude of all eight classical planets in degrees, range [0, 360).
is_retrograde(p, t)
Returns true if the planet is currently in retrograde motion (geocentric speed < 0) == 0 = stationary.
Parameters:
p (series Planet) : The planet to check.
t (float) : Time in Unix timestamp (milliseconds).
Returns: true if the planet is in retrograde, false otherwise.
Library
lib_vsop87_mercuryLibrary "lib_vsop87_mercury"
Heliocentric and geocentric position calculations for Mercury
using VSOP87 theory. Provides longitude, latitude, radius, speed,
and declination functions.
@author BlueprintResearch (Javonnii)
@license MIT License - Free to use with attribution
@theory VSOP87A (Heliocentric rectangular coordinates)
@accuracy Truncated series (~10-15 terms per series) - arcsecond precision
@time_scale Julian millennia from J2000.0 (use core.get_julian_millennia)
@reference Meeus, Jean. "Astronomical Algorithms" (2nd Ed., 1998)
Bretagnon & Francou. "VSOP87 Solutions" (1988)
@showcase Includes commented showcase code with 250-bar future projection.
Uncomment to display Mercury data with polyline projections.
@open_source This library is part of an open-source alternative to
proprietary astronomical libraries. Study, modify, and
share freely. We believe knowledge of the cosmos belongs
to everyone.
════════════════════════════════════════════════════════════════
© 2025 BlueprintResearch / Javonnii
Licensed under MIT License
════════════════════════════════════════════════════════════════
@version=6
import BlueprintResearch/lib_vsop_core/1 as core
get_helio_lon(t)
Computes Mercury's heliocentric ecliptic longitude using VSOP87 theory.
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Heliocentric ecliptic longitude in degrees, normalized to range [0, 360).
get_helio_lat(t)
Computes Mercury's heliocentric ecliptic latitude using VSOP87 theory.
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Heliocentric ecliptic latitude in radians, range approximately . Note: Returns radians, not degrees.
get_helio_radius(t)
Computes Mercury's heliocentric radius (distance from Sun) using VSOP87 theory.
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Heliocentric radius in astronomical units (AU). Typical range is 0.31-0.47 AU.
get_geo_speed(t)
Computes Mercury's geocentric longitude speed (rate of change over time).
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Geocentric longitude speed in degrees per day. Negative values indicate retrograde motion (apparent backward movement).
get_geo_lon(t)
Computes Mercury's geocentric ecliptic longitude (as seen from Earth).
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Geocentric ecliptic longitude in degrees, normalized to range [0, 360).
get_geo_ecl_lat(t)
Computes Mercury's geocentric ecliptic latitude (as seen from Earth).
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Geocentric ecliptic latitude in degrees, range approximately .
get_geo_decl(t)
Computes Mercury's geocentric equatorial declination (as seen from Earth).
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Geocentric equatorial declination in degrees, range where positive is north. Library
lib_vsop87_venusLibrary "lib_vsop87_venus"
Heliocentric and geocentric position calculations for Venus
using VSOP87 theory. Provides longitude, latitude, radius, speed,
and declination functions.
@author BlueprintResearch (Javonnii)
@license MIT License - Free to use with attribution
@theory VSOP87A (Heliocentric rectangular coordinates)
@accuracy Truncated series (~10-15 terms per series) - arcsecond precision
@time_scale Julian millennia from J2000.0 (use core.get_julian_millennia)
@reference Meeus, Jean. "Astronomical Algorithms" (2nd Ed., 1998)
Bretagnon & Francou. "VSOP87 Solutions" (1988)
@showcase Includes commented showcase code with 250-bar future projection.
Uncomment to display Venus data with polyline projections.
@open_source This library is part of an open-source alternative to
proprietary astronomical libraries. Study, modify, and
share freely. We believe knowledge of the cosmos belongs
to everyone.
════════════════════════════════════════════════════════════════
© 2025 BlueprintResearch / Javonnii
Licensed under MIT License
════════════════════════════════════════════════════════════════
@version=6
import BlueprintResearch/lib_vsop_core/1 as core
get_helio_lon(t)
Computes Venus's heliocentric ecliptic longitude using VSOP87 theory.
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Heliocentric ecliptic longitude in degrees, normalized to range [0, 360).
get_helio_lat(t)
Computes Venus's heliocentric ecliptic latitude using VSOP87 theory.
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Heliocentric ecliptic latitude in radians, range approximately . Note: Returns radians, not degrees.
get_helio_radius(t)
Computes Venus's heliocentric radius (distance from Sun) using VSOP87 theory.
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Heliocentric radius in astronomical units (AU). Typical range is 0.72-0.73 AU.
get_geo_speed(t)
Computes Venus's geocentric longitude speed (rate of change over time).
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Geocentric longitude speed in degrees per day. Negative values indicate retrograde motion (apparent backward movement).
get_geo_lon(t)
Computes Venus's geocentric ecliptic longitude (as seen from Earth).
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Geocentric ecliptic longitude in degrees, normalized to range [0, 360).
get_geo_ecl_lat(t)
Computes Venus's geocentric ecliptic latitude (as seen from Earth).
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Geocentric ecliptic latitude in degrees, range approximately .
get_geo_decl(t)
Computes Venus's geocentric equatorial declination (as seen from Earth).
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Geocentric equatorial declination in degrees, range where positive is north. Library
Library
Library
Library
Library
lib_vsop87_uranusLibrary "lib_vsop87_uranus"
Heliocentric and geocentric position calculations for Uranus
using VSOP87 theory. Provides longitude, latitude, radius, speed,
and declination functions.
@author BlueprintResearch (Javonnii)
@license MIT License - Free to use with attribution
@theory VSOP87A (Heliocentric rectangular coordinates)
@accuracy Truncated series (~10-15 terms per series) - arcsecond precision
@time_scale Julian millennia from J2000.0 (use core.get_julian_millennia)
@reference Meeus, Jean. "Astronomical Algorithms" (2nd Ed., 1998)
Bretagnon & Francou. "VSOP87 Solutions" (1988)
@showcase Includes commented showcase code with 250-bar future projection.
Uncomment to display Uranus data with polyline projections.
@open_source This library is part of an open-source alternative to
proprietary astronomical libraries. Study, modify, and
share freely. We believe knowledge of the cosmos belongs
to everyone.
════════════════════════════════════════════════════════════════
© 2025 BlueprintResearch / Javonnii
Licensed under MIT License
════════════════════════════════════════════════════════════════
@version=6
import BlueprintResearch/lib_vsop_core/1 as core
get_helio_lon(t)
Computes Uranus's heliocentric ecliptic longitude using VSOP87 theory.
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Heliocentric ecliptic longitude in degrees, normalized to range [0, 360).
get_helio_lat(t)
Computes Uranus's heliocentric ecliptic latitude using VSOP87 theory.
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Heliocentric ecliptic latitude in radians, range approximately . Note: Returns radians, not degrees.
get_helio_radius(t)
Computes Uranus's heliocentric radius (distance from Sun) using VSOP87 theory.
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Heliocentric radius in astronomical units (AU). Typical range is 18.28-20.09 AU.
get_geo_speed(t)
Computes Uranus's geocentric longitude speed (rate of change over time).
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Geocentric longitude speed in degrees per day. Negative values indicate retrograde motion (apparent backward movement).
get_geo_lon(t)
Computes Uranus's geocentric ecliptic longitude (as seen from Earth).
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Geocentric ecliptic longitude in degrees, normalized to range [0, 360).
get_geo_ecl_lat(t)
Computes Uranus's geocentric ecliptic latitude (as seen from Earth).
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Geocentric ecliptic latitude in degrees, range approximately .
get_geo_decl(t)
Computes Uranus's geocentric equatorial declination (as seen from Earth).
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Geocentric equatorial declination in degrees, range where positive is north. Library
lib_vsop87_neptuneLibrary "lib_vsop87_neptune"
Heliocentric and geocentric position calculations for Neptune
using VSOP87 theory. Provides longitude, latitude, radius, speed,
and declination functions.
@author BlueprintResearch (Javonnii)
@license MIT License - Free to use with attribution
@theory VSOP87A (Heliocentric rectangular coordinates)
@accuracy Truncated series (~10-15 terms per series) - arcsecond precision
@time_scale Julian millennia from J2000.0 (use core.get_julian_millennia)
@reference Meeus, Jean. "Astronomical Algorithms" (2nd Ed., 1998)
Bretagnon & Francou. "VSOP87 Solutions" (1988)
@showcase Includes commented showcase code with 250-bar future projection.
Uncomment to display Neptune data with polyline projections.
@open_source This library is part of an open-source alternative to
proprietary astronomical libraries. Study, modify, and
share freely. We believe knowledge of the cosmos belongs
to everyone.
════════════════════════════════════════════════════════════════
© 2025 BlueprintResearch / Javonnii
Licensed under MIT License
════════════════════════════════════════════════════════════════
@version=6
import BlueprintResearch/lib_vsop_core/1 as core
get_helio_lon(t)
Computes Neptune's heliocentric ecliptic longitude using VSOP87 theory.
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Heliocentric ecliptic longitude in degrees, normalized to range [0, 360).
get_helio_lat(t)
Computes Neptune's heliocentric ecliptic latitude using VSOP87 theory.
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Heliocentric ecliptic latitude in radians, range approximately . Note: Returns radians, not degrees.
get_helio_radius(t)
Computes Neptune's heliocentric radius (distance from Sun) using VSOP87 theory.
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Heliocentric radius in astronomical units (AU). Typical range is 29.81-30.33 AU.
get_geo_speed(t)
Computes Neptune's geocentric longitude speed (rate of change over time).
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Geocentric longitude speed in degrees per day. Negative values indicate retrograde motion (apparent backward movement).
get_geo_lon(t)
Computes Neptune's geocentric ecliptic longitude (as seen from Earth).
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Geocentric ecliptic longitude in degrees, normalized to range [0, 360).
get_geo_ecl_lat(t)
Computes Neptune's geocentric ecliptic latitude (as seen from Earth).
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Geocentric ecliptic latitude in degrees, range approximately .
get_geo_decl(t)
Computes Neptune's geocentric equatorial declination (as seen from Earth).
Parameters:
t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).
Returns: (float) Geocentric equatorial declination in degrees, range where positive is north. Library
lib_meeus_plutoLibrary "lib_meeus_pluto"
Heliocentric and geocentric position calculations for Pluto using
Meeus truncated analytical series. Valid ±1 century from J2000.
@author BlueprintResearch (Javonnii)
@license MIT License - Free to use with attribution
@theory Meeus truncated series (not full planetary theory)
@accuracy Arcminute precision within ±1 century of J2000
@time_scale Julian centuries from J2000.0 (use core.get_julian_centuries)
@reference Meeus, Jean. "Astronomical Algorithms" (2nd Ed., 1998), Chapter 37
@showcase Includes commented showcase code with 250-bar future projection.
Uncomment to display Pluto data with polyline projections.
@open_source This library is part of an open-source alternative to
proprietary astronomical libraries. Study, modify, and
share freely. We believe knowledge of the cosmos belongs
to everyone.
════════════════════════════════════════════════════════════════
© 2025 BlueprintResearch / Javonnii
Licensed under MIT License
════════════════════════════════════════════════════════════════
@version=6
import BlueprintResearch/lib_vsop_core/1 as core
get_helio_lon(t)
Computes Pluto's heliocentric ecliptic longitude using Meeus truncated analytical series.
Parameters:
t (float) : (float) Julian centuries from J2000.0 (use core.get_julian_centuries(time)).
Returns: (float) Heliocentric ecliptic longitude in degrees, normalized to range [0, 360). Accurate within ±1 century from J2000.
get_helio_lat(t)
Computes Pluto's heliocentric ecliptic latitude using Meeus truncated analytical series.
Parameters:
t (float) : (float) Julian centuries from J2000.0 (use core.get_julian_centuries(time)).
Returns: (float) Heliocentric ecliptic latitude in degrees, range approximately . Accurate within ±1 century from J2000.
get_helio_radius(t)
Computes Pluto's heliocentric radius (distance from Sun) using Meeus truncated analytical series.
Parameters:
t (float) : (float) Julian centuries from J2000.0 (use core.get_julian_centuries(time)).
Returns: (float) Heliocentric radius in astronomical units (AU). Typical range is 29.6-49.3 AU. Accurate within ±1 century from J2000.
get_geo_lon(t)
Computes Pluto's geocentric ecliptic longitude (as seen from Earth).
Parameters:
t (float) : (float) Julian centuries from J2000.0 (use core.get_julian_centuries(time)).
Returns: (float) Geocentric ecliptic longitude in degrees, normalized to range [0, 360).
get_geo_ecl_lat(t)
Computes Pluto's geocentric ecliptic latitude (as seen from Earth).
Parameters:
t (float) : (float) Julian centuries from J2000.0 (use core.get_julian_centuries(time)).
Returns: (float) Geocentric ecliptic latitude in degrees, range approximately .
get_geo_decl(t)
Computes Pluto's geocentric equatorial declination (as seen from Earth).
Parameters:
t (float) : (float) Julian centuries from J2000.0 (use core.get_julian_centuries(time)).
Returns: (float) Geocentric equatorial declination in degrees, range where positive is north.
get_geo_speed(t)
Computes Pluto's geocentric longitude speed (rate of change over time).
Parameters:
t (float) : (float) Julian centuries from J2000.0 (use core.get_julian_centuries(time)).
Returns: (float) Geocentric longitude speed in degrees per day. Negative values indicate retrograde motion (apparent backward movement). Library
lib_vsop_coreLibrary "lib_vsop_core"
Foundation library providing core types, evaluators, and utilities
for VSOP87 planetary theory calculations. Required by all planetary
libraries. Includes Earth heliocentric model and Sun geocentric functions.
@author BlueprintResearch (Javonnii)
@license MIT License - Free to use with attribution
@theory VSOP87 (Variations Séculaires des Orbites Planétaires)
@accuracy Truncated series - suitable for financial astrology and education
@time_scale Julian millennia from J2000.0 for VSOP87 planets
Julian centuries from J2000.0 for Moon and Pluto
@reference Meeus, Jean. "Astronomical Algorithms" (2nd Ed., 1998)
Bretagnon & Francou. "VSOP87 Solutions" (1988)
@showcase Includes commented showcase code with 250-bar future projection.
Uncomment to display Sun/Earth data with polyline projections.
@open_source This library is part of an open-source alternative to
proprietary astronomical libraries. Study, modify, and
share freely. We believe knowledge of the cosmos belongs
to everyone.
════════════════════════════════════════════════════════════════
© 2025 BlueprintResearch / Javonnii
Licensed under MIT License
════════════════════════════════════════════════════════════════
@version=6
get_julian_millennia(time_)
Parameters:
time_ (float)
get_julian_centuries(time_)
Parameters:
time_ (float)
eval_vsop87(terms, t)
Parameters:
terms (array)
t (float)
eval_vsop87_derivative(terms, t)
Parameters:
terms (array)
t (float)
mod360(x)
Parameters:
x (float)
custom_atan2(y, x)
Parameters:
y (float)
x (float)
get_earth_helio_radius(t)
Parameters:
t (float)
get_earth_helio_coords(t)
Parameters:
t (float)
get_obliquity(t)
Parameters:
t (float)
get_earth_helio_lon(t)
Parameters:
t (float)
get_sun_geo_lon(t)
Parameters:
t (float)
get_sun_geo_speed(t)
Parameters:
t (float)
get_sun_decl(t)
Parameters:
t (float)
get_bar_gap_ms()
Get bar interval in milliseconds for current timeframe
Returns: (int) Time interval between bars in milliseconds
get_future_time(current_time, bars_ahead)
Calculate future timestamp for projection plotting
Parameters:
current_time (int) : (int) Current bar time in milliseconds (use built-in 'time')
bars_ahead (int) : (int) Number of bars to project into future
Returns: (int) Future timestamp suitable for xloc.bar_time and chart.point.from_time
is_projection_bar()
Check if current bar is suitable for drawing future projections
Returns: (bool) True on last bar when projections should be drawn
vsop_term
Fields:
amp (series float)
phase (series float)
freq (series float) Library
Indicator
Astro: Moon SizeThe Astro: Moon Size indicator, built using AstroLib , calculates the distance and visualizes the apparent size of the Moon based on astronomical positioning. This script is tailored for the 1D timeframe and provides insights into lunar perigees (closest approach) and apogees (farthest distance), making it useful for astrologically-informed trading strategies.
New Astro Indicators Feature:
By setting the Julian Date to X number of days in the future, and offsetting the plot by X number of bars accordingly, it is now possible to visualize future projections of PulseWire indicators that reference the AstroLib . This feature has been long requested and is far overdue, so thank you to everyone who pushed for this feature release. Enjoy, time travelers from the future!!
Key Features:
Moon Size Calculation: Uses Julian Date (J2000) conversion and AstroLib functions to determine the Moon's apparent distance.
Future Projection: Displays the Moon's distance from 28 up to 500 days ahead, with color gradients indicating proximity/size.
Pivot Identification: Marks local maxima (apogees) and minima (perigees) with labeled date stamps for easy reference.
Dynamic Labeling: Adapts label positioning and size based on the Moon's current trend and relative size.
Usage Notes:
⚠️ Timeframe Restriction: For now, the script only functions on the 1D timeframe and will prompt an error otherwise.
⚠️ Asset Restriction: This script is meant to be loaded on charts for assets that trade 24/7, like BTCUSD historical index. Indicator
Indicator
Astro: Celestial Body LongitudesThis is fork of the previous Astro: Planetary Longitudes indicator that now includes over a dozen different celestial bodies, made possible after the most recent update of the AstroLib library .
Celestial longitude is a measurement of the position of a celestial body in its orbit around the Sun, expressed in degrees of arc along the plane of the body's orbit. It is one of the fundamental coordinates used in astronomy to describe the position of a planet or other celestial object.
The concept of longitude is important in astrology, where it is used to determine the position of the planets in the zodiac. In this context, the longitude is measured along the ecliptic, which is the apparent path of the Sun on the celestial sphere. Astrologers use the position of the planets in the zodiac to make predictions and interpretations about personality traits, life events, earthquakes, market events, and other aspects of human experience.
This indicator includes geocentric/heliocentric longitude lines with retrograde identification, Vedic Nakshatras, and astrological zodiac & aspects for each of the celestial bodies. Hover over labels for additional information. Indicator
Indicator
Astro: Celestial CoordinatesCelestial coordinates are a system of measurements used in astronomy and astrology to describe the positions of celestial objects such as stars, planets, and constellations. There are several different celestial coordinates, including right ascension (RA), longitude, latitude, declination, and altitude. Each coordinate has its own astronomical or astrological significance, as outlined below:
Right ascension (RA) is a coordinate used to describe the position of an object in the sky along the celestial equator. It is measured in hours, minutes, and seconds and is analogous to longitude on Earth. RA is significant in both astronomy and astrology because it allows astronomers and astrologers to accurately locate celestial objects in the sky.
Longitude is a coordinate used to describe the position of a planet or other object in its orbit around the Sun. It is measured in degrees and is significant in astronomy because it allows astronomers to accurately predict the positions of planets and other objects in the solar system.
Latitude is a coordinate used to describe the position of an object in the sky relative to the celestial equator. It is measured in degrees and is significant in both astronomy and astrology because it helps astronomers and astrologers to determine the positions of celestial objects in the sky.
Declination is a coordinate used to describe the position of an object in the sky relative to the celestial equator, similar to latitude but measured in degrees north or south of the celestial equator. It is significant in astronomy because it allows astronomers to accurately locate objects in the sky.
Altitude is a coordinate used to describe the height of an object above the horizon. It is measured in degrees and is significant in both astronomy and astrology because it allows astronomers and astrologers to determine when objects will be visible in the sky and at what angle.
In astrology, celestial coordinates are used to create maps of the positions of celestial objects. This indicator plots the corresponding celestial coordinate
values for each planet, moon, or sun and labels key turning (pivot) points with a date (& optional time). Hover over labels for additional information. Indicator
Astro: Planetary SpeedPlanetary speed refers to the rate at which a planet moves along its orbit around the Sun. The speed of a planet can vary depending on its distance from the Sun, and is generally fastest at the point in its orbit where it is closest to the Sun (perihelion) and slowest at the point where it is farthest from the Sun (aphelion).
The significance of planetary speeds lies in their astrological interpretation. In astrology, the speed of a planet is thought to influence its energy and influence earthly affairs. Fast-moving planets, such as Mercury and Venus, are believed to have a more immediate and fleeting influence, while slower-moving planets, such as Jupiter and Saturn, are thought to have a more long-lasting and significant impact.
Astrologers use the speed of the planets, along with their positions, aspects, and other factors, to interpret their influence. By understanding the energy and symbolism associated with each planet, astrologers can provide insight and guidance to individuals seeking a greater understanding. Indicator
Astro: Solar SystemA bird's eye view model of the solar system is a simplified representation of our planetary system as seen from above. It can be thought of as a two-dimensional map of the solar system, in which the planets are shown in their approximate heliocentric longitudinal positions relative to the Sun and each other.
In this model, the Sun is shown as a large, central emoji, with the planets arranged in orbits around it. The inner planets - Mercury, Venus, Earth, and Mars - are located close to the Sun and inside the asteroid belt, while the outer planets - Jupiter, Saturn, Uranus, Neptune, and Pluto- are located farther out.
In a bird's eye view model, some of the details of the solar system are necessarily left out or simplified. For example, the distances between the planets are not to scale, and the orbits are shown as perfect circles rather than the elliptical shapes they actually are. Nonetheless, this model can provide a useful visual real-time representation of the relative heliocentric longitudinal positions (aspects) of the planets in our solar system.
🏅 Shoutout to @LuxAlgo for the circle code! Indicator
Indicator
Indicator
