// ------------------------------------------------------------------------------- // Cumulative Volume Delta (CVD) displays buy/sell volume difference accumulated during some period. // Supports SMA and EMA smoothing. // // Version 1.00 // Copyright 2025, EarnForex.com // https://www.earnforex.com/indicators/CVD/ // ------------------------------------------------------------------------------- using System; using cAlgo.API; namespace cAlgo { [Indicator(IsOverlay = false, AccessRights = AccessRights.None)] public class CVD : Indicator { // Enumeration for smoothing type. public enum SmoothingMethod { None, // No Smoothing SMA, // Simple Moving Average EMA // Exponential Moving Average } // Input parameters. [Parameter("Source Timeframe", DefaultValue = "Current")] public TimeFrame DataTimeframe { get; set; } [Parameter("Cumulative Period", DefaultValue = 20, MinValue = 1)] public int CumulativePeriod { get; set; } [Parameter("Smoothing Method", DefaultValue = SmoothingMethod.None)] public SmoothingMethod SmoothMethod { get; set; } [Parameter("Smoothing Period", DefaultValue = 1, MinValue = 1)] public int SmoothPeriod { get; set; } // Output buffers. [Output("CVD Positive", LineColor = "LimeGreen", PlotType = PlotType.Histogram, Thickness = 2)] public IndicatorDataSeries CVDPositive { get; set; } [Output("CVD Negative", LineColor = "Red", PlotType = PlotType.Histogram, Thickness = 2)] public IndicatorDataSeries CVDNegative { get; set; } [Output("CVD Smoothed", LineColor = "DarkGray", PlotType = PlotType.Line, LineStyle = LineStyle.Dots)] public IndicatorDataSeries CVDSmooth { get; set; } // Internal data series. private IndicatorDataSeries CVDRaw; private IndicatorDataSeries DeltaVolume; // Multi-timeframe bars. private Bars lowerTFBars; // EMA multiplier. private double alpha; protected override void Initialize() { // Initialize internal data series. CVDRaw = CreateDataSeries(); DeltaVolume = CreateDataSeries(); // Get lower timeframe bars. if (DataTimeframe.Name == "Current") { lowerTFBars = Bars; } else { lowerTFBars = MarketData.GetBars(DataTimeframe); } // Check if selected timeframe is valid. if (lowerTFBars.TimeFrame > Bars.TimeFrame) { Print("Warning: Data timeframe should be equal to or lower than the current chart timeframe. Using current timeframe."); lowerTFBars = Bars; } // Calculate EMA multiplier. alpha = 2.0 / (SmoothPeriod + 1.0); } public override void Calculate(int index) { // Check for sufficient data. if (index < CumulativePeriod) { CVDPositive[index] = 0; CVDNegative[index] = 0; CVDSmooth[index] = 0; return; } // Calculate non-cumulative delta volume for current bar. DeltaVolume[index] = CalculateVolumeDelta(index); // Calculate rolling cumulative delta over fixed period. double rollingSumDelta = 0; int periodsToSum = Math.Min(CumulativePeriod, index + 1); // Sum delta volume for the last N bars (including current bar). for (int j = 0; j < periodsToSum; j++) { rollingSumDelta += DeltaVolume[index - j]; } CVDRaw[index] = rollingSumDelta; // Apply smoothing. ApplySmoothing(index); // Split values into positive and negative buffers for histogram display. if (CVDSmooth[index] >= 0) { CVDPositive[index] = CVDSmooth[index]; CVDNegative[index] = 0; } else { CVDPositive[index] = 0; CVDNegative[index] = CVDSmooth[index]; } } private double CalculateVolumeDelta(int barIndex) { // Get current bar time. DateTime barTime = Bars.OpenTimes[barIndex]; DateTime nextBarTime = Bars.OpenTimes[barIndex + 1]; // A newer bar. if (IsLastBar) nextBarTime = DateTime.Now; // No newer bar. // Find corresponding bars in lower timeframe. int lowerTFStartIndex = lowerTFBars.OpenTimes.GetIndexByTime(barTime); if (lowerTFStartIndex < 0 || lowerTFBars.OpenTimes[lowerTFStartIndex] < barTime) return 0; double totalDelta = 0; // Accumulate delta from all lower timeframe bars within current bar. for (int i = lowerTFStartIndex; i < lowerTFBars.Count; i++) { // Check if still within current bar timeframe. if (lowerTFBars.OpenTimes[i] >= nextBarTime) break; // Get OHLC and volume for lower timeframe bar. double ltfHigh = lowerTFBars.HighPrices[i]; double ltfLow = lowerTFBars.LowPrices[i]; double ltfClose = lowerTFBars.ClosePrices[i]; double ltfVolume = lowerTFBars.TickVolumes[i]; // Calculate delta using price position within range. double range = ltfHigh - ltfLow; double buyVolume = 0; double sellVolume = 0; if (range > 0) { // Estimate buy/sell volume based on close position in range. double closePosition = (ltfClose - ltfLow) / range; buyVolume = ltfVolume * closePosition; sellVolume = ltfVolume * (1 - closePosition); totalDelta += (buyVolume - sellVolume); } } return totalDelta; } private void ApplySmoothing(int index) { if (SmoothPeriod <= 1 || SmoothMethod == SmoothingMethod.None) { CVDSmooth[index] = CVDRaw[index]; } else if (SmoothMethod == SmoothingMethod.SMA) { CVDSmooth[index] = CalculateSMA(index, SmoothPeriod, CVDRaw); } else if (SmoothMethod == SmoothingMethod.EMA) { CVDSmooth[index] = CalculateEMA(index, SmoothPeriod, CVDRaw); } } private double CalculateSMA(int index, int period, IndicatorDataSeries source) { if (period <= 0 || index < period - 1) { return source[index]; } double sum = 0; int count = 0; for (int i = 0; i < period && index - i >= 0; i++) { sum += source[index - i]; count++; } return count > 0 ? sum / count : source[index]; } private double CalculateEMA(int index, int period, IndicatorDataSeries source) { if (period <= 0) { return source[index]; } // Initialize with SMA for the first value. if (index < period) { return CalculateSMA(index, index + 1, source); } // For the first complete period, use SMA. if (index == period - 1 || double.IsNaN(CVDSmooth[index - 1])) { return CalculateSMA(index, period, source); } // EMA formula: (Current - Previous EMA) * multiplier + Previous EMA. return (source[index] - CVDSmooth[index - 1]) * alpha + CVDSmooth[index - 1]; } } }