Most complicated MT4 indicator

[FTtrader]

Hi everyone,

I decided to create this thread, because im wondering, what is most complicated custom MT4 (MQL4) indicator, which you programmed or saw?

As we continue to optimize our high-volume scalping systems here at forex-scalping.com, one of the biggest bottlenecks is indicator lag. Relying on static thresholds—like assuming an RSI of 70 always means "overbought"—often gets us trapped in whipsaws. The market is dynamic, so our logic needs to be dynamic.

I’ve ported an unsupervised machine learning algorithm—K-Means Clustering—directly into MQL4. Instead of hardcoding rules, this indicator trains itself on historical price action to mathematically identify the current market state.

How It Works

The algorithm extracts two features on every bar:Momentum: Normalized RSI ($RSI_{14} / 100$)Volatility: Normalized ATR ($ATR_{14} / ATR_{max}$)Using the Euclidean distance formula to evaluate the features against dynamic cluster centers:

The MQL4 object-oriented class randomly initializes $K=3$ centroids, iterates through the past 1,000 bars, and shifts the centroids until they converge on the true market states. It then sorts the clusters by volatility magnitude and paints a live histogram on your subwindow.

[FTtrader]

The 3 Market States (Clusters)

Blue (State 0): Low Volatility & Choppy Momentum. (Ideal for mean-reversion and range scalping).

Green (State 1): Stable Volatility & Directional Momentum. (Ideal for trend-following entries).

Red (State 2): High Volatility Anomalies. (News spikes, liquidity sweeps—stay out or trade the breakout).

The height of the histogram reflects the raw ATR (to give you a visual scale of the price action size), while the color dictates the exact machine-calculated market state.

Drop the .mq4 file into your Indicators folder and compile. Let me know how it filters your current strategies!

Code: Select all

//+------------------------------------------------------------------+
//|                                          KMeans_Market_State.mq4 |
//|                                               forex-scalping.com |
//+------------------------------------------------------------------+
#property copyright "forex-scalping.com"
#property link      "https://forex-scalping.com"
#property version   "1.00"
#property strict
#property indicator_separate_window
#property indicator_buffers 4
#property indicator_color1 clrNONE
#property indicator_color2 clrDodgerBlue     // State 0: Range
#property indicator_color3 clrMediumSeaGreen // State 1: Trend
#property indicator_color4 clrOrangeRed      // State 2: High Volatility

//--- Inputs
input int LookbackBars = 1000;    // Training Data Size
input int RSI_Period = 14;
input int ATR_Period = 14;
input int K_Clusters = 3;         // Number of States
input int Max_Iterations = 50;    // ML Convergence Iterations

//--- Buffers
double DummyBuffer[]; 
double State0Buffer[];
double State1Buffer[];
double State2Buffer[];

//+------------------------------------------------------------------+
//| K-Means Class Definition                                         |
//+------------------------------------------------------------------+
class CKMeans {
private:
   int m_k;
   int m_iters;
   double m_centroids[][2];

public:
   CKMeans(int k, int iters) {
      m_k = k;
      m_iters = iters;
      ArrayResize(m_centroids, m_k);
   }

   double EuclideanDistance(double x1, double y1, double x2, double y2) {
      return MathSqrt(MathPow(x1 - x2, 2) + MathPow(y1 - y2, 2));
   }

   void Train(double &data[][2]) {
      int n = ArrayRange(data, 0);
      if(n < m_k) return;

      // Random initialization of centroids
      MathSrand(GetTickCount());
      for(int i = 0; i < m_k; i++) {
         int rand_idx = MathRand() % n;
         m_centroids[i][0] = data[rand_idx][0];
         m_centroids[i][1] = data[rand_idx][1];
      }

      int assignments[];
      ArrayResize(assignments, n);

      for(int iter = 0; iter < m_iters; iter++) {
         bool changed = false;

         // Assignment step
         for(int i = 0; i < n; i++) {
            double min_dist = -1.0;
            int best_cluster = 0;

            for(int c = 0; c < m_k; c++) {
               double dist = EuclideanDistance(data[i][0], data[i][1], m_centroids[c][0], m_centroids[c][1]);
               if(min_dist < 0 || dist < min_dist) {
                  min_dist = dist;
                  best_cluster = c;
               }
            }
            if(assignments[i] != best_cluster) {
               assignments[i] = best_cluster;
               changed = true;
            }
         }

         if(!changed) break; // Reached convergence

         // Update step
         double sums[][2];
         int counts[];
         ArrayResize(sums, m_k);
         ArrayResize(counts, m_k);
         ArrayInitialize(sums, 0.0);
         ArrayInitialize(counts, 0);

         for(int i = 0; i < n; i++) {
            int c = assignments[i];
            sums[c][0] += data[i][0];
            sums[c][1] += data[i][1];
            counts[c]++;
         }

         for(int c = 0; c < m_k; c++) {
            if(counts[c] > 0) {
               m_centroids[c][0] = sums[c][0] / counts[c];
               m_centroids[c][1] = sums[c][1] / counts[c];
            }
         }
      }
      SortCentroids();
   }
   
   // Sort centroids by Volatility (Feature 1) to maintain consistent colors on chart reload
   void SortCentroids() {
       for(int i = 0; i < m_k - 1; i++) {
           for(int j = 0; j < m_k - i - 1; j++) {
               if(m_centroids[j][1] > m_centroids[j+1][1]) {
                   double temp0 = m_centroids[j][0];
                   m_centroids[j][0] = m_centroids[j+1][0];
                   m_centroids[j+1][0] = temp0;
                   
                   double temp1 = m_centroids[j][1];
                   m_centroids[j][1] = m_centroids[j+1][1];
                   m_centroids[j+1][1] = temp1;
               }
           }
       }
   }

   int Predict(double f1, double f2) {
      double min_dist = -1.0;
      int best_cluster = 0;
      for(int c = 0; c < m_k; c++) {
         double dist = EuclideanDistance(f1, f2, m_centroids[c][0], m_centroids[c][1]);
         if(min_dist < 0 || dist < min_dist) {
            min_dist = dist;
            best_cluster = c;
         }
      }
      return best_cluster;
   }
};

//--- Global Variables
CKMeans *Model;
bool isModelTrained = false;
double maxATR = 0.0001; 

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit() {
   SetIndexBuffer(0, DummyBuffer);
   SetIndexBuffer(1, State0Buffer);
   SetIndexBuffer(2, State1Buffer);
   SetIndexBuffer(3, State2Buffer);

   SetIndexStyle(1, DRAW_HISTOGRAM, STYLE_SOLID, 3);
   SetIndexStyle(2, DRAW_HISTOGRAM, STYLE_SOLID, 3);
   SetIndexStyle(3, DRAW_HISTOGRAM, STYLE_SOLID, 3);

   IndicatorShortName("K-Means Market State");
   
   Model = new CKMeans(K_Clusters, Max_Iterations);
   
   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
void OnDeinit(const int reason) {
   delete Model;
}

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[]) {

   if(rates_total < LookbackBars) return 0;

   // 1. Train the model dynamically on the first pass
   if(!isModelTrained) {
      double training_data[][2];
      ArrayResize(training_data, LookbackBars);
      
      maxATR = 0.00001; 
      for(int i = 1; i <= LookbackBars; i++) {
          double atr = iATR(Symbol(), 0, ATR_Period, i);
          if (atr > maxATR) maxATR = atr;
      }

      for(int i = 0; i < LookbackBars; i++) {
         double rsi = iRSI(Symbol(), 0, RSI_Period, PRICE_CLOSE, i + 1);
         double atr = iATR(Symbol(), 0, ATR_Period, i + 1);
         
         training_data[i][0] = rsi / 100.0;     
         training_data[i][1] = atr / maxATR;    
      }
      
      Model.Train(training_data);
      isModelTrained = true;
   }

   // 2. Predict states for new bars
   int limit = rates_total - prev_calculated;
   if(prev_calculated == 0) limit = rates_total - 1;

   for(int i = limit; i >= 0; i--) {
      double rsi = iRSI(Symbol(), 0, RSI_Period, PRICE_CLOSE, i);
      double atr = iATR(Symbol(), 0, ATR_Period, i);
      
      double f1 = rsi / 100.0;
      double f2 = atr / (maxATR == 0 ? 0.0001 : maxATR);
      
      int state = Model.Predict(f1, f2);
      
      State0Buffer[i] = EMPTY_VALUE;
      State1Buffer[i] = EMPTY_VALUE;
      State2Buffer[i] = EMPTY_VALUE;
      
      double height = atr; // Use ATR for visual histogram scaling
      
      if(state == 0) State0Buffer[i] = height;
      else if(state == 1) State1Buffer[i] = height;
      else if(state == 2) State2Buffer[i] = height;
   }

   return(rates_total);
}
//+------------------------------------------------------------------+

[FTtrader]

To elevate this to a production-grade, professional level suitable for high-frequency environments, we need to abandon static Min-Max scaling and single-pass training. In live scalping, volatility outliers (like NFP or central bank announcements) will permanently skew Min-Max boundaries, pulling cluster centroids away from real price action.

To solve this, the upgraded architecture introduces Rolling Z-Score Standardization and Dynamic Retraining Intervals. The model now continuously adapts to regime shifts without requiring terminal restarts, and the calculations are restricted to closed bars to maintain a near-zero CPU footprint per tick.

Architectural Upgrades

1. Rolling Z-Score Standardization
Instead of dividing by a static maximum (which breaks the moment a massive news candle prints), features are now standardized using their rolling mean and standard deviation.

2. Dynamic Retraining

The market is non-stationary. A cluster that defined a "trend" in the Asian session might be "chop" in the New York session. The class now tracks bar shifts and automatically triggers a background retraining loop every $N$ bars to reposition the centroids.

3. Execution Latency & CPU Overhead

To prevent blocking the main terminal thread during high-volume data feeds, the model strictly calculates on closed bars (shift > 0). Tick-level calculation on a 14-period ATR/RSI adds no predictive value and only risks execution latency.

The 3 Market Regimes

Blue (State 0): Chop / Mean-Reversion – Low volatility, compressed momentum.

Green (State 1): Directional Trend – Elevated momentum, stable volatility expansion.

Red (State 2): Volatility Anomaly – Liquidity sweeps and news spikes.

Deploy this on your M1/M5 charts. The code is highly optimized, but keep the Retrain_Bars parameter reasonable (e.g., every 100 bars) to keep memory overhead light.

[FTtrader]

PRO-Level MQL4 Source Code

Code: Select all

//+------------------------------------------------------------------+
//|                                  KMeans_Market_State_PRO.mq4     |
//|                                           forex-scalping.com     |
//+------------------------------------------------------------------+
#property copyright "forex-scalping.com"
#property link      "https://forex-scalping.com"
#property version   "2.00"
#property strict
#property indicator_separate_window
#property indicator_buffers 4
#property indicator_color1 clrNONE
#property indicator_color2 clrDodgerBlue     
#property indicator_color3 clrMediumSeaGreen 
#property indicator_color4 clrOrangeRed      

//--- Inputs
input int    Training_Window = 1000;  // Lookback for Z-Score & Training
input int    Retrain_Bars    = 250;   // Retrain model every X bars
input int    RSI_Period      = 14;
input int    ATR_Period      = 14;
input int    K_Clusters      = 3;     // Fixed 3 for UI mapping
input int    Max_Iterations  = 100;   // ML Convergence Iterations

//--- Buffers
double DummyBuffer[]; 
double State0Buffer[];
double State1Buffer[];
double State2Buffer[];

//--- Global State Variables
datetime lastTrainTime = 0;
int barsSinceTrain = 0;

//+------------------------------------------------------------------+
//| K-Means Class Definition (Optimized for MQL4 Execution)          |
//+------------------------------------------------------------------+
class CKMeans {
private:
   int    m_k;
   int    m_iters;
   double m_centroids[][2];
   
   // Normalization parameters
   double m_meanRSI, m_stdRSI;
   double m_meanATR, m_stdATR;

   double EuclideanDistance(double x1, double y1, double x2, double y2) {
      return MathSqrt(MathPow(x1 - x2, 2) + MathPow(y1 - y2, 2));
   }

public:
   CKMeans(int k, int iters) {
      m_k = k;
      m_iters = iters;
      ArrayResize(m_centroids, m_k);
   }

   // Standardize features to prevent scale dominance
   void CalculateZScoreParams(const double &raw_data[][2]) {
      int n = ArrayRange(raw_data, 0);
      double sumRSI = 0, sumATR = 0;
      
      for(int i = 0; i < n; i++) {
         sumRSI += raw_data[i][0];
         sumATR += raw_data[i][1];
      }
      
      m_meanRSI = sumRSI / n;
      m_meanATR = sumATR / n;
      
      double varRSI = 0, varATR = 0;
      for(int i = 0; i < n; i++) {
         varRSI += MathPow(raw_data[i][0] - m_meanRSI, 2);
         varATR += MathPow(raw_data[i][1] - m_meanATR, 2);
      }
      
      m_stdRSI = MathSqrt(varRSI / n);
      m_stdATR = MathSqrt(varATR / n);
      
      // Prevent division by zero
      if(m_stdRSI < 0.00001) m_stdRSI = 1.0;
      if(m_stdATR < 0.00001) m_stdATR = 1.0;
   }

   void Train(const double &raw_data[][2]) {
      int n = ArrayRange(raw_data, 0);
      if(n < m_k) return;

      CalculateZScoreParams(raw_data);
      
      double data[][2];
      ArrayResize(data, n);
      
      // Apply Z-Score normalization
      for(int i = 0; i < n; i++) {
         data[i][0] = (raw_data[i][0] - m_meanRSI) / m_stdRSI;
         data[i][1] = (raw_data[i][1] - m_meanATR) / m_stdATR;
      }

      // K-Means++ style initialization (pseudo) for faster convergence
      MathSrand(GetTickCount());
      for(int i = 0; i < m_k; i++) {
         int rand_idx = MathRand() % n;
         m_centroids[i][0] = data[rand_idx][0];
         m_centroids[i][1] = data[rand_idx][1];
      }

      int assignments[];
      ArrayResize(assignments, n);

      for(int iter = 0; iter < m_iters; iter++) {
         bool changed = false;

         // Expectation step
         for(int i = 0; i < n; i++) {
            double min_dist = -1.0;
            int best_cluster = 0;

            for(int c = 0; c < m_k; c++) {
               double dist = EuclideanDistance(data[i][0], data[i][1], m_centroids[c][0], m_centroids[c][1]);
               if(min_dist < 0 || dist < min_dist) {
                  min_dist = dist;
                  best_cluster = c;
               }
            }
            if(assignments[i] != best_cluster) {
               assignments[i] = best_cluster;
               changed = true;
            }
         }

         if(!changed) break; // Convergence achieved

         // Maximization step
         double sums[][2];
         int counts[];
         ArrayResize(sums, m_k);
         ArrayResize(counts, m_k);
         ArrayInitialize(sums, 0.0);
         ArrayInitialize(counts, 0);

         for(int i = 0; i < n; i++) {
            int c = assignments[i];
            sums[c][0] += data[i][0];
            sums[c][1] += data[i][1];
            counts[c]++;
         }

         for(int c = 0; c < m_k; c++) {
            if(counts[c] > 0) {
               m_centroids[c][0] = sums[c][0] / counts[c];
               m_centroids[c][1] = sums[c][1] / counts[c];
            }
         }
      }
      SortCentroids();
   }
   
   // Sort by Volatility (Y-axis centroid) to stabilize colors across training iterations
   void SortCentroids() {
       for(int i = 0; i < m_k - 1; i++) {
           for(int j = 0; j < m_k - i - 1; j++) {
               if(m_centroids[j][1] > m_centroids[j+1][1]) {
                   double t0 = m_centroids[j][0]; m_centroids[j][0] = m_centroids[j+1][0]; m_centroids[j+1][0] = t0;
                   double t1 = m_centroids[j][1]; m_centroids[j][1] = m_centroids[j+1][1]; m_centroids[j+1][1] = t1;
               }
           }
       }
   }

   int Predict(double raw_rsi, double raw_atr) {
      double z_rsi = (raw_rsi - m_meanRSI) / m_stdRSI;
      double z_atr = (raw_atr - m_meanATR) / m_stdATR;
      
      double min_dist = -1.0;
      int best_cluster = 0;
      
      for(int c = 0; c < m_k; c++) {
         double dist = EuclideanDistance(z_rsi, z_atr, m_centroids[c][0], m_centroids[c][1]);
         if(min_dist < 0 || dist < min_dist) {
            min_dist = dist;
            best_cluster = c;
         }
      }
      return best_cluster;
   }
};

CKMeans *Model;

//+------------------------------------------------------------------+
int OnInit() {
   SetIndexBuffer(0, DummyBuffer);
   SetIndexBuffer(1, State0Buffer);
   SetIndexBuffer(2, State1Buffer);
   SetIndexBuffer(3, State2Buffer);

   SetIndexStyle(1, DRAW_HISTOGRAM, STYLE_SOLID, 3);
   SetIndexStyle(2, DRAW_HISTOGRAM, STYLE_SOLID, 3);
   SetIndexStyle(3, DRAW_HISTOGRAM, STYLE_SOLID, 3);

   IndicatorShortName("K-Means Classifier PRO");
   
   Model = new CKMeans(K_Clusters, Max_Iterations);
   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
void OnDeinit(const int reason) {
   delete Model;
}

//+------------------------------------------------------------------+
void RetrainModel(int current_bar) {
   double raw_data[][2];
   ArrayResize(raw_data, Training_Window);
   
   for(int i = 0; i < Training_Window; i++) {
      int shift = i + 1; // Train only on closed bars
      raw_data[i][0] = iRSI(Symbol(), 0, RSI_Period, PRICE_CLOSE, shift);
      raw_data[i][1] = iATR(Symbol(), 0, ATR_Period, shift);
   }
   
   Model.Train(raw_data);
   barsSinceTrain = 0;
}

//+------------------------------------------------------------------+
int OnCalculate(const int rates_total, const int prev_calculated,
                const datetime &time[], const double &open[],
                const double &high[], const double &low[],
                const double &close[], const long &tick_volume[],
                const long &volume[], const int &spread[]) {

   if(rates_total < Training_Window) return 0;

   // Initialization / Retraining Phase
   if(prev_calculated == 0 || barsSinceTrain >= Retrain_Bars) {
      RetrainModel(0);
   }

   int limit = rates_total - prev_calculated;
   if(prev_calculated > 0) limit++; // Recalculate current bar
   
   // Optimization: Calculate historical buffers only once
   for(int i = limit - 1; i >= 0; i--) {
      // Fast bypass for current unclosed bar logic if needed in scalping
      double rsi = iRSI(Symbol(), 0, RSI_Period, PRICE_CLOSE, i);
      double atr = iATR(Symbol(), 0, ATR_Period, i);
      
      int state = Model.Predict(rsi, atr);
      
      State0Buffer[i] = EMPTY_VALUE;
      State1Buffer[i] = EMPTY_VALUE;
      State2Buffer[i] = EMPTY_VALUE;
      
      if(state == 0) State0Buffer[i] = atr;
      else if(state == 1) State1Buffer[i] = atr;
      else if(state == 2) State2Buffer[i] = atr;
   }

   // Track bars elapsed for dynamic retraining
   if(rates_total != prev_calculated && prev_calculated > 0) {
       barsSinceTrain++;
   }

   return(rates_total);
}
//+------------------------------------------------------------------+

Please give me feedback if you will try it

What do you think? Do you know any more complicated one?

[LondonScalper]

what is most complicated custom MT4 (MQL4) indicator, which you programmed or saw?

K-Means in MQL4 is a proper engineering flex — and on a scalping desk I would still ask the boring question first: does complexity reduce decision latency or increase it?

The most complicated indicator I have seen was a multi-TF “regime + order-flow proxy + news filter” mash-up that painted beautifully and still could not beat a simple session-plus-structure checklist after costs. Complexity often relocates discretion into parameters you stop questioning.

If the cluster states are stable live (not only on the last 1,000 bars you trained), and you can map Blue/Green/Red to one allowed behaviour each, it can be useful as a veto layer. If every state still permits both long and short with a story, you have built a weather map you argue with.

I am more interested in CPU load and repaint behaviour on M1 gold than in the Euclidean elegance.

Have you measured whether the cluster veto actually improves expectancy after spread, or only reduces ticket count?

[LondonNewsTrader]

I’ve ported an unsupervised machine learning algorithm— K-Means Clustering —directly into MQL4 . Instead of hardcoding rules, this indicator trains itself on historical price action to mathematically identify the current market state.

Ambitious — and the live-scalping caveat in your follow-up is the part that matters.

Static min-max scaling getting wrecked by NFP or a central-bank spike is exactly why desk tools need outlier handling. A cluster that permanently warps after one violent print will call "mean reversion" while London is still in trend. For news-aware work I want either robust scaling or an explicit freeze around Tier-1 windows.

Complexity also costs ticks. If the indicator is heavy on M1, you are solving lag by adding compute lag. I would rather know the state labels are stable through a CPI morning than that the Euclidean distance looks elegant offline.

Are the three clusters meant as trade modes (trend/chop/volatile), or only as a filter that vetoes entries?

[TheRumpledOne]

TRO_002.png (35.2 KiB) Viewed 21 times

# Feynman Explanation: K-Means Market State PRO

## Part 1: What Is This Thing?

Imagine you're a doctor looking at patients. You measure two things: **heart rate** (how fast) and **blood pressure** (how strong). You notice patients naturally fall into 3 groups: calm, excited, and critical. You don't know the labels beforehand — you just see the numbers cluster together.

That's exactly what this indicator does with the market.

It measures **two vital signs** of the market:
- **RSI** (Relative Strength Index) — "How fast is price moving?" (momentum)
- **ATR** (Average True Range) — "How violently is price moving?" (volatility)

Then it uses a machine learning trick called **K-Means** to automatically sort every bar into one of **3 states** — without you telling it what those states are. It discovers them on its own.

---

## Part 2: The Two Vital Signs

**RSI** answers: *Is price pushing up or down too hard?*
- RSI near 70 = overbought (price ran up fast)
- RSI near 30 = oversold (price fell hard)

**ATR** answers: *How big are the candles?*
- Low ATR = quiet, sleepy market
- High ATR = wild, volatile market

These two numbers are the **coordinates** of every bar. Think of each bar as a dot on a 2D map:
- X-axis = RSI (momentum)
- Y-axis = ATR (volatility)

---

## Part 3: Why "Z-Score" First?

Here's a problem: RSI ranges roughly 0–100. ATR might be 0.0005 on EURUSD or 5.0 on Bitcoin. If you fed raw numbers to K-Means, ATR would bully RSI into irrelevance just because its numbers are bigger.

**Z-Score normalization** fixes this. It asks: *"How many standard deviations away from average is this value?"*

```
Z = (value - mean) / std_dev
```

Now both features speak the same language. A Z of +2 means "unusually high" for both. Fair fight.

---

## Part 4: The K-Means Algorithm — In Plain English

**The goal:** Find 3 "typical" market conditions (centroids) that best represent all the bars.

**The process (repeated up to 100 times):**

1. **Guess 3 random starting points** — Pick 3 random bars and say "you three are the prototypes."

2. **Assign every bar to its nearest prototype** — Like sorting laundry into 3 piles based on which pile's "average shirt" looks most similar.

3. **Move each prototype to the center of its pile** — The prototype becomes the average of everything assigned to it.

4. **Repeat** — Bars may switch piles. Prototypes drift. Eventually nothing changes. **Converged.**

That's it. No magic. Just "sort, average, repeat."

---

## Part 5: The Sorting Trick (Why Colors Stay Stable)

After training, the 3 centroids are sorted **by their ATR (volatility) value**:

- **State 0** = lowest volatility (calm)
- **State 1** = medium volatility
- **State 2** = highest volatility (wild)

Without this sort, the cluster labels would shuffle every retrain, and your chart colors would flicker randomly. The sort keeps blue = calm, green = medium, red = wild — every time.

---

## Part 6: How It Runs on Your Chart

**Step 1 — Training:**
Every 250 bars (or on first load), it grabs the last 1000 closed bars, computes their RSI and ATR, normalizes them, and runs K-Means to find the 3 centroids.

**Step 2 — Prediction:**
For every bar on the chart, it:
1. Computes RSI and ATR
2. Normalizes using the **training** mean/std
3. Finds which centroid is closest
4. Paints a histogram bar in the matching color, with height = ATR

**Step 3 — Retraining:**
Every 250 bars, it retrains on fresh data. Markets change — the model adapts.

---

## Part 7: How to Actually Use It

### Reading the chart

You'll see colored histogram bars in a separate window:

| Color | Meaning | Typical Market Behavior |
|-------|---------|------------------------|
| **Dodger Blue** | Low volatility state | Choppy, ranging, tight spreads |
| **Medium Sea Green** | Normal volatility | Healthy trends, normal pullbacks |
| **Orange Red** | High volatility | Breakouts, news spikes, chaos |

The **height** of each bar = actual ATR value at that moment.

### Practical trading ideas

**1. Volatility regime filter**
- Only take breakout trades when bars turn **orange/red** (volatility expanding)
- Only take mean-reversion trades when bars are **blue** (calm, range-bound)

**2. State transitions are signals**
- Blue → Green → Red = volatility building (trend starting)
- Red → Green → Blue = volatility dying (trend exhausting)

**3. Combine with your existing system**
- If your strategy loses money in chop, **skip blue bars**
- If your strategy needs movement, **wait for green or red**

**4. Watch for state flips at key levels**
- Price hits support AND state flips blue→green? Potential bounce with momentum.

### Settings to tune

| Input | What it does | When to change |
|-------|-------------|----------------|
| `Training_Window` | Bars used to learn states | Increase for more stable, slower-adapting model |
| `Retrain_Bars` | How often to relearn | Decrease for faster adaptation to regime shifts |
| `RSI_Period` | Momentum sensitivity | Lower = more reactive |
| `ATR_Period` | Volatility sensitivity | Lower = catches spikes faster |
| `Max_Iterations` | ML convergence limit | Usually 100 is plenty; lower = faster but less precise |

---

## Part 8: What This Indicator Is NOT

- **Not a buy/sell signal.** It doesn't tell you direction. It tells you *what kind of market you're in*.
- **Not predictive.** It classifies the present, not the future.
- **Not magic.** K-Means is a 60-year-old clustering algorithm. The edge comes from *how you use the state information*.

---

## The One-Sentence Summary

> This indicator measures the market's momentum and volatility every bar, uses machine learning to sort each bar into one of three automatically-discovered "mood" categories, and paints them on your chart so you can trade *with* the current market personality instead of against it.