Indicator Math V2 (indicator_math_v2) 🚀

ไลบรารี Rust ประสิทธิภาพสูงสำหรับการวิเคราะห์ทางเทคนิคทางการเงิน (Financial Technical Analysis) ที่ถูกออกแบบมาเพื่อ สืบทอดและเพิ่มประสิทธิภาพ ของลอจิกจาก clsAnalysisGenerator.js โดยเฉพาะ

ด้วยการออกแบบใหม่ทั้งหมด ทำให้ indicator_math_v2 มีจุดเด่นในเรื่องการประมวลผลแบบขนาน (Parallel Processing) และการวิเคราะห์แบบสะสม (Incremental Analysis) ซึ่งเบาและเร็วกว่าตัวเก่าอย่างเทียบไม่ติด

---

✨ คุณสมบัติเด่น (Features)

1. ⚡ Parallel Asset Processing (คำนวณหลายคู่เงินพร้อมกันแบบไร้คอขวด)

ใช้พลังของ tokio (Asynchronous Runtime) และ rayon (Data-parallelism) ในการกระจายงานคำนวณอินดิเคเตอร์ของหลายคู่เงินไปรันบน CPU หลายๆ Core พร้อมกัน ทำให้เซิร์ฟเวอร์สามารถรับโหลดได้จำนวนมหาศาล

2. 🧠 Incremental State Management (O(1) Update Time)

ลาก่อนการคำนวณซ้ำ O(N): ในเวอร์ชันปกตินั้น เวลาคุณมีข้อมูลตั้งต้น 1,000 แท่ง เมื่อมี Tick ใหม่มา 1 ครั้ง ระบบจะคำนวณใหม่ไล่ตั้งแต่แท่งที่ 1 ยัน 1,001 (เสียเวลามาก)

แต่ V2 ฉลาดกว่า: ระบบมี GeneratorState คอยจดจำ "ค่าตัวแปรสุดท้าย" เอาไว้ (เช่น EMA ของแท่งล่าสุด) ทำให้เมื่อมีราคา Tick เข้ามา ระบบจะเอา ราคาใหม่ + ค่าใน State เดิม มาคำนวณได้ทันที (ใช้แค่ 1 Operation (O(1)) ไม่ใช่พันครั้ง!) ทำให้เบากระชากใจ

3. 🌐 Built-in Deriv Integration

มีโค้ดจัดการการดึงข้อมูล OHLC ย้อนหลังจาก Deriv WebSocket/API ในตัว ไม่ต้องเขียนโค้ดยิง API เองให้เมื่อย โหลดข้อมูลตั้งต้นเป็นร้อยเป็นพันกราฟได้สบายๆ รวดเดียว

4. 🧮 Comprehensive Indicators

มีชุดอินดิเคเตอร์ครบครันและได้รับการรีไรต์ให้เข้ากับการทำงานแบบ State (Incremental):

• Moving Averages: EMA, HMA, EHMA, WMA
• Momentum/Trend: RSI, MACD, ADX
• Volatility: ATR, Bollinger Bands, Choppiness Index (CI)
• Smart Money Concepts (SMC): Market Structure (CHoCH, BOS), Swing Points, Order Blocks, FVG, Premium/Discount Zones

5. 🎯 Status Code Matching

ตัวนี้ทีเด็ด! มันสามารถวิเคราะห์และรวมอินดิเคเตอร์สิบกว่าตัว แล้วสรุปสถานะแท่งเทียนนั้นออกมาให้เป็น SeriesCode ตัวแปรเดียว (เช่น M-UU-G-C) ซึ่งตรงกับรูปแบบ CandleMasterCode ที่เอาไว้ใช้พิจารณาเข้าเทรดได้เลยอัตโนมัติ ไม่ต้องมานั่งเขียน if-else เอง อัปเดตใหม่: ระบบรองรับการตั้งค่าดึงกฎแบบ Dynamic JSON ในตอนสั่งบิลด์ ทำให้สามารถอ่านและอัปเดตกฎเทรดจากไฟล์ CodeCandleMaster.json (จาก root โปรเจกต์) ได้โดยไม่ต้องไปแกะและฮาร์ดโค้ดใน Library อีกต่อไป

6. 🌍 WebAssembly (Wasm) First

คุณสามารถนำคณิตศาสตร์ดั้งเดิมไปรันบน Client/Browser ได้โดยตรง! ตอนนี้เรารองรับโหมด CPU Wasm เพื่อให้นำฟังก์ชันประเมินกราฟราคาแบบ Incremental ไปฝังให้ Web Worker ของโปรเจกต์ React/Vue ใช้งานแบบเรียลไทม์ได้ทันที!

---

🛠️ โครงสร้างฟังก์ชันหลัก (Key Functions)

ตัวจัดการหลักของไลบรารีนี้คือ AnalysisManager ซึ่งมีฟังก์ชันที่คุณจะได้ใช้บ่อยๆ ดังนี้:

1. AnalysisManager::new(options, master_codes)

• ใช้ทำอะไร: สร้าง Instance บริหารการคำนวณขึ้นมาใหม่
• พารามิเตอร์ที่รับ: รับ AnalysisOptions (ตั้งค่าว่าจะเอา Period เท่าไหร่) และ master_codes (กติกา Status Code ว่าแบบไหนเรียกว่าอะไร)

2. manager.initialize(ws_url, assets).await

• ใช้ทำอะไร: ดึงข้อมูลแท่งเทียนย้อนหลังของรายชื่อเหรียญ (assets) ผ่าน Web Socket URL ที่ให้ไป จากนั้นมันจะคำนวณอินดิเคเตอร์ย้อนหลังทั้งหมดทีเดียวและเก็บข้อมูลไว้ใน State ให้พร้อมใช้งาน
• เหมาะสำหรับ: การบู้ท (Boot Up) ระบบครั้งแรก

3. manager.process_tick(asset, price, epoch)

• ใช้ทำอะไร: เป็นหัวใจหลักของโหมด Live Trading เมื่อมีสัญญาณราคาขยับ (Tick) ส่งราคาล่าสุด (price) ไปให้ มันก็จะเอาไปเช็คดูว่าปิดแท่งเทียนเดิมรึยัง
  • ถ้าปิดแล้ว ระบบก็จะ "คืนค่า (Return)" ไฟล์ AnalysisResult กลับมาบอกผลวิเคราะห์ของแท่งล่าสุดทันที
  • ถ้ายังไม่ปิด มันก็แค่เซฟไว้และคืนค่า None
• ประสิทธิภาพ: O(1) เร็วและไม่กิน CPU อย่างที่กล่าวไปข้างต้น

4. manager.get_all_status()

• ใช้ทำอะไร: สำหรับเรียกดู "สถานะล่าสุด" ของทุกคู่เงินที่เราได้สั่งให้มันทำงานไว้ มันจะรวบรวมข้อมูลสถานะ (Status Code) แปะมาให้ทันที เอาไปโชว์ใน Web / Mobile ได้ง่ายสุดๆ

---

📦 วิธีการติดตั้ง

เพิ่มมันลงใน Cargo.toml ระบบคุณ ดังนี้:

[dependencies]

indicator_math_v2 = { package = "indicator_math", path = "RustLib/indicator_math" }

tokio = { version = "1.0", features = ["full"] }

ปล. ต้องใช้คู่กับแพ็กเกจ tokio เสมอเพราะมันเป็นระบบทำงานขนานแบบ Asynchronous

---

🔗 วิธีการใช้งาน (Integration Guide)

1. การเชื่อมต่อกับ main.rs (Backend)

การนำไปใช้ใน main.rs นั้น คุณจะต้องสร้าง AnalysisManager เอาไว้เป็น Global State/Shared State ผ่านตระกูล Arc<Mutex<>> หรือ Arc<RwLock<>> เพื่อให้ระบบ WebSocket หรือ Thread ต่างๆ เข้ามาเรียกใช้พร้อมกันได้

ตัวอย่างโค้ดใน main.rs:

use indicator_math_v2::{AnalysisManager, AnalysisOptions, CandleMasterCode};
use std::sync::Arc;
use tokio::sync::RwLock;

// สร้างข้อมูล State รวมที่สามารถแชร์ไปใน Axum (หรือ WebSocket) ได้
type SharedManager = Arc<RwLock<AnalysisManager>>;

#[tokio::main]
async fn main() {
    // 1. ตั้งค่าและสร้าง Manager
    let options = AnalysisOptions::default();
    
    // (จำลอง) เตรียม Master Code กติกาเทรด
    let master_codes = vec![
        CandleMasterCode { status_code: "1".to_string(), status_desc: "L-DD-E-D".to_string() },
    ];
    let manager = AnalysisManager::new(options, master_codes);
    let shared_manager: SharedManager = Arc::new(RwLock::new(manager));

    // 2. สั่งให้ Manager โหลดข้อมูลกราฟย้อนหลัง (Initialization)
    let ws_url = "wss://ws.binaryws.com/websockets/v3?app_id=1089";
    let assets = vec!["R_100".to_string(), "R_50".to_string()];
    
    // ดึง Thread ไปรันย้อนหลัง
    {
        let mut mgr = shared_manager.write().await;
        let _ = mgr.initialize(ws_url, assets).await;
        println!("🚀 ดึงข้อมูลกราฟตั้งต้นเสร็จสมบูรณ์");
    }

    // 3. จำลอง Event เวลา Tick เข้ามา (Live Data)
    // ตรงนี้นำไปเชื่อมกับ WebSocket Client ของคุณเวลาได้รับ Tick ใหม่
    let mut mgr = shared_manager.write().await;
    if let Some((asset, result)) = mgr.process_tick("R_100", 123.45, 1700000060) {
        // เมื่อถึงเวลา ปิดแท่ง Manager จะคาย AnalysisResult ออกมาให้
        println!("📊 แท่งเทียนใหม่ปิดแล้ว! {}: โค้ดที่ได้={}", asset, result.status_code);
        
        // 🚨 สั่ง Broadcast (ยิง WebSocket) กลับไปให้ Frontend อัปเดต Lightweight Charts
        // let payload = json!({ "asset": asset, "data": result });
        // tx.send(payload.to_string());
    }
}

2. ข้อมูลล้ำค่าที่ส่งกลับไปให้ Main (Actionable Data)

เมื่อ indicatorMath_ULTRA_Rust ประมวลผลแท่งเทียนเสร็จ มันจะคายก้อน AnalysisResult (struct ขนาดใหญ่) ตัดส่งกลับไปให้ Main ของ Rust ผ่านฟังก์ชัน process_tick โดยแบ่งกลุ่มค่าสำคัญที่ส่งกลับไปพิจารณาการเข้าเทรด ดังนี้:

1. ทิศราชสีห์ (เทรนด์หลักจากเส้น EMA)

มันแยกให้เลยว่าเส้น EMA 3 ระดับกำลังหัวเชิด หรือหัวปัก

• ema_short_direction, ema_medium_direction, ema_long_direction: (ได้ค่า "Up", "Down", "Flat")
• ema_above, ema_long_above: เอาไว้ดูว่าเส้นสั้นอยู่เหนือเส้นยาวไหม ("ShortAbove", "MediumAbove", "LongAbove") ช่วยหาจุด Golden Cross
• ema_short_turn_type: ("TurnUp" หักหัวขึ้น, "TurnDown" หักหัวลง) อันนี้ใช้จับจุดกลับตัวแบบไวโคตรๆ ได้

2. สถานะความผันผวนของตลาด (Indicators อื่นๆ)

• rsi_value: ค่า RSI 0-100 ไว้ดู Overbought / Oversold
• bb_position: ราคาอยู่ในโซนไหนของ Bollinger Bands ("NearUpper", "NearLower", "Middle") เหมาะทำสาย Reversal (ชนขอบแล้วเด้งกลับ)
• choppy_indicator: หาว่าตลาดช่วงนี้ "มีเทรนด์" (ค่าน้อย) หรือ "สวิงไซด์เวย์" (ค่ามาก)
• adx_value: วัด "ความแข็งแกร่งของเทรนด์" (ADX > 25 แปลว่าเทรนด์แข็งแรงสุดๆ)

3. ชันสูตรแท่งเทียน (Candlestick Anatomy)

เหมาะกับคนที่เทรดด้วย Price Action หรือล่า Price Rejection (ไส้เทียนยาว)

• body_percent: เนื้อเทียนคิดเป็นกี่เปอร์เซ็นต์ของทั้งแท่ง
• u_wick_percent, l_wick_percent: ไส้เทียนบนและล่างยาวกี่เปอร์เซ็นต์ (เช่น ถ้า l_wick_percent ยาวมากตอนอยู่แถวแนวรับ ก็อาจจับจังหวะ Call/Buy ได้)
• is_abnormal_candle, is_abnormal_atr: ค่า Boolean ห้ามเทรดตอนที่บอกว่า "จริง (True)" เพราะหมายถึงเกิดข่าวลากไส้รุนแรง ราคาช็อกตลาด

4. ร่องรอยรายใหญ่ (Smart Money Concepts - SMC)

วิเคราะห์พฤติกรรมกลไกราคาเชิงลึก:

• swing_trend, internal_trend: เทรนด์ของสวิงหลักและสวิงย่อย ("bullish", "bearish")
• structures: จุดทะลุโครงสร้าง CHoCH (Change of Character) และ BOS (Break of Structure)
• order_blocks: โซนคำสั่งซื้อขายก้อนใหญ่ที่เกิดจากการทิ้งตัวแรงๆ (Bullish/Bearish Order Blocks)
• fair_value_gaps: โพรงราคา (FVG) ที่แท่งเทียนพุ่งแรงจนเกิดช่องว่าง
• premium_discount_zone: โซนราคาถูก (Discount) และโซนของแพง (Premium)

5. รหัสลับสถานะ (The Master Code)

ตัวนี้เอาไว้ยัดรวมสภาพตลาดทุกอย่างเป็นบรรทัดเดียว เบ็ดเสร็จ:

• status_desc: เช่น ค่า "L-DU-U-R-C" (ยาวกว่า Medium, สั้นตัดกลางทิ่มหัวลง, ยาวชี้หัวขึ้น, แท่งสีแดง, แมคดีชนกัน)
• status_code: โค้ดแปลจากหน้าเทรด เป็นตัวเลขเช่น "25", "13"

ตัวอย่างการนำไปเขียน Logics ตัดสินใจเทรดใน Main:

// ตัวอย่างที่ 1: เล่นตามน้ำ (Follow Trend) จากรหัสสถานะ
if analysis.status_desc == "L-UU-U-G-D" && analysis.adx_value.unwrap_or(0.0) > 25.0 {
    // เทรนด์ขาขึ้น 100% (MediumเหนือLong-ชี้ขึ้นหมด-แท่งเขียว-Divergeออก)
    // แถม ADX บอกเทรนด์แข็งแกร่ง -> ส่งคำสั่ง "BUY (Call)" ไปที่ Exchange ได้เลย!
    execute_trade("CALL", asset, amount);
}

// ตัวอย่างที่ 2: ดักจับจุดกลับตัวแบบมีไส้ (Rejection on BB Lower)
if analysis.bb_position == "NearLower" && analysis.l_wick_percent > 60.0 {
    // ราคาไหลไปแตะขอบล่าง Bollinger Bands แถมทิ้งไส้ล่างยาวเกิน 60% ของแท่ง (มีแรงซื้อสวน)
    // ถือเป็นสัญญาณ Call ระยะสั้นที่ดีมาก
    execute_trade("CALL", asset, amount);
}

// ตัวอย่างที่ 3: ระบบป้องภัย 
if analysis.is_abnormal_candle || analysis.choppy_indicator.unwrap_or(100.0) > 61.8 {
    // แท่งเทียนผันผวนผิดปกติ หรือตลาดแกว่ง Choppy Index สูงเกินไป
    // ให้บอทถือเงินสดไว้เฉยๆ ไม่เสี่ยงเข้าเทรด
    pause_trading(asset);
}

3. การนำไปใช้กับ Lightweight Charts (Frontend)

เมื่อ Backend รัน process_tick() ได้แท่งเทียนปิดและวิเคราะห์เสร็จ มันจะคืนรูปมาเป็นค่าต่างๆ เช่น open, high, low, close, ema_short_value, rsi_value

สิ่งที่คุณต้องทำบน Frontend (HTML/JS) คือ เอาตัวแปลเหล่านั้นป้อนใส่ TradingView Lightweight Charts คล้ายกับวิธีดั้งเดิม:

ตัวอย่างโค้ดฝั่ง Javascript:

// 1. สร้างชาร์ตแท่งเทียนหลักและเส้น EMA
const chart = LightweightCharts.createChart(document.getElementById('chart'), { width: 800, height: 400 });
const candleSeries = chart.addCandlestickSeries();
const emaSeries = chart.addLineSeries({ color: 'blue', lineWidth: 2 });

// 2. รอรับข้อมูล JSON จาก WebSocket Rust
socket.onmessage = function(event) {
    const msg = JSON.parse(event.data);
    
    // ถ้าข้อความที่ระบุว่าเป็นข้อมูลจากการวิเคราะห์ปิดแท่ง
    if (msg.type === "ANALYSIS_UPDATE" && msg.asset === "R_100") {
        const data = msg.data; // ตรงนี้คือ FullAnalysis ที่แปลงเป็น JSON
        
        // 3. อัปเดตแท่งเทียนราคา
        candleSeries.update({
            time: data.candle_time, // Time stamp (Epoch) ของแท่ง
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close,
        });

        // 4. วาดตัวชี้วัด (Indicator) บนกราฟเดียวกัน (เช่น เส้น EMA Short)
        if (data.ema_short_value !== null) {
            emaSeries.update({
                time: data.candle_time,
                value: data.ema_short_value,
            });
        }
        
        // *คุณสามารถนำ `data.rsi_value` ไปวาดบนกราฟแยกด้านล่าง (Oscillator Chart) ได้*
        // *หรือนำ `data.suggest_color` มาทำ Indicator สีซื้อขายแปะบนแท่งเทียนได้เช่นกัน*
    }
};

4. การนำไปใช้บนหน้าเว็บ (WebAssembly Wasm) สำหรับ Frontend แข็งแกร่ง

ในเวอร์ชันนี้ ระบบรองรับการนำไลบรารีไปรันพ่วงกับโปรเจกต์ React/Vue/HTML ดิบ ผ่าน WebAssembly ได้โดยตรง ซึ่งมี 2 โหมดการประมวลผล:

โหมด CPU Wasm (Incremental Ticking) ⚡

ใช้สำหรับการอัปเดตราคาแบบทีละ Tick ตามเรียลไทม์ แบบเดียวบนฝั่งเซิร์ฟเวอร์ แต่รันผ่าน Web Worker ประจำเครื่องลูกค้าแทน:

<script type="module">
    import init, { WasmAnalysisGenerator } from './wasm_dist/indicatorMath_ULTRA_Rust.js';

    async function run() {
        await init(); // โหลด Wasm

        // 1. จำลองการตั้งค่า Option เหมือนใน Rust
        const options = { ema1_period: 20, ema1_type: "EMA", /*...ตั้งค่าอื่นๆ*/ };
        const generator = new WasmAnalysisGenerator(JSON.stringify(options));

        // 2. ป้อนประวัติเก่าเข้าไปครั้งแรก (Array ของแท่งเทียน)
        generator.initialize(JSON.stringify(history_candles));

        // 3. ป้อนราคา Live Tick สดๆ
        let result = generator.append_tick(150.5, 1700000000); 
        
        if (result) {
            console.log("ปิดแท่งเทียนแล้ว! ได้รหัส:", result.status_desc);
        }
    }
    run();
</script>

โหมด GPU Wasm (WebGPU Array Computation) 🚀(Experimental)

ใช้พลังมหาศาลของการ์ดจอ (GPU) บนเบราว์เซอร์ คำนวณขนานหลักล้านข้อมูลเสร็จใน 1 มิลลิวินาที! (เหมาะสำหรับโหลด History 10,000 แท่ง หรือดูทีละ 1,000 คู่เหรียญพร้อมกัน):

<script type="module">
    import init, { GpuAnalysisManager } from './wasm_dist/indicatorMath_ULTRA_Rust.js';

    async function run() {
        await init();
        
        // ร้องขอใช้งานการ์ดจอ (GPU) บน Web
        const gpuManager = await GpuAnalysisManager.initialize();
        
        // เตรียมข้อมูลราคานับล้านแท่ง
        const prices = new Float32Array([...หลักล้านตัวเลข...]);

        // ยิงข้อมูลใส่ VRAM เพื่อประมวลผลผ่าน Compute Shader
        const result = await gpuManager.dispatch_compute(prices);
        
        console.log("คำนวณ SMA(20) นับล้านแท่งเสร็จแล้ว:", result);
    }
    run();
</script>

---

📦 โครงสร้างข้อมูล JSON (AnalysisResult) และคำอธิบายฟิลด์

เมื่อ indicatorMath_ULTRA_Rust คำนวณจบแต่ละแท่งเทียน จะทำการคืนค่ากลับมาในรูปแบบ Struct ซึ่งเมื่อส่งข้าม WebSocket ไปยังหน้า Frontend (หรือตอนแปลงเป็น JSON) จะมีหน้าตาและรายละเอียดดังนี้:

{
  "index": 120,
  "candletime": 1700000060,
  "candletime_display": "2024-XX-XX HH:MM:SS",
  "open": 100.5,
  "high": 101.2,
  "low": 99.8,
  "close": 101.0,
  "color": "Green",
  "next_color": null,
  "pip_size": 0.5,
  
  "ema_short_value": 100.8,
  "ema_short_direction": "Up",
  "ema_short_turn_type": "TurnUp",
  
  "ema_medium_value": 100.2,
  "ema_medium_direction": "Up",
  
  "ema_long_value": 99.5,
  "ema_long_direction": "Flat",
  
  "ema_above": "ShortAbove",
  "ema_long_above": "MediumAbove",
  
  "macd_12": 0.6,
  "macd_23": 0.7,
  
  "previous_ema_short_value": 100.6,
  "previous_ema_medium_value": 100.1,
  "previous_ema_long_value": 99.5,
  "previous_macd_12": 0.5,
  "previous_macd_23": 0.6,
  
  "ema_convergence_type": "divergence",
  "ema_long_convergence_type": "D",
  
  "choppy_indicator": 45.2,
  "adx_value": 28.5,
  "rsi_value": 65.4,
  
  "bb_values": {
    "upper": 102.5,
    "middle": 100.0,
    "lower": 97.5
  },
  "bb_position": "NearUpper",
  
  "atr": 1.4,
  "is_abnormal_candle": false,
  "is_abnormal_atr": false,
  
  "u_wick": 0.2,
  "u_wick_percent": 14.28,
  "body": 0.5,
  "body_percent": 35.71,
  "l_wick": 0.7,
  "l_wick_percent": 50.0,
  
  "ema_cut_position": "B1",
  "ema_cut_long_type": "UpTrend",
  "candles_since_ema_cut": 5,
  
  "up_con_medium_ema": 3,
  "down_con_medium_ema": 0,
  "up_con_long_ema": 10,
  "down_con_long_ema": 0,
  
  "is_mark": "n",
  "status_code": "14",
  "status_desc": "M-UU-U-G-D",
  "status_desc_0": "M-UU-U-G-D",
  "hint_status": "",
  "suggest_color": "",
  "win_status": "",
  "win_con": 0,
  "loss_con": 0,
  
  "smc": {
    "structures": [
      {
        "time": 1700000000,
        "price": 99.0,
        "structure_type": "BOS",
        "direction": "bullish",
        "level": "swing",
        "start_time": 1699999000
      }
    ],
    "swing_points": [
      {
        "time": 1700000000,
        "price": 102.0,
        "swing_type": "HH",
        "swing": "high"
      }
    ],
    "order_blocks": [],
    "fair_value_gaps": [],
    "equal_highs_lows": [],
    "premium_discount_zone": {
      "start_time": 1699995000,
      "end_time": 1700000060,
      "premium_top": 105.0,
      "premium_bottom": 104.5,
      "equilibrium": 100.0,
      "discount_top": 95.5,
      "discount_bottom": 95.0
    },
    "strong_weak_levels": [],
    "swing_trend": "bullish",
    "internal_trend": "bearish"
  }
}

คำอธิบายการใช้งานในแต่ละตัวแปร 📝

หมวดหมู่ข้อมูลทั่วไปของแท่งเทียน (Basic Candle Info):

• index: ตำแหน่งเรียงลำดับของแท่งเทียนตั้งแต่เริ่ม (History length)
• candletime: เวลาของปิดแท่งเทียนฉบับ Epoch Time (วินาที)
• candletime_display: เวลาที่ถูกจัดการเป็น String (Optional)
• open, high, low, close: ข้อมูลราคาพื้นฐาน
• color: สีของแท่งเทียน ("Green", "Red", "Equal")
• next_color: ใช้ในกรณีวิเคราะห์แท่งเทียนแบบย้อนหลัง (จะรู้สีแท่งในอนาคตเพื่อการทำ Backtesting ได้)
• pip_size: ขนาดส่วนต่างของราคาเปรียบเทียบจาก Open-Close

หมวดหมู่เส้นค่าเฉลี่ย (Moving Averages - EMA/HMA/WMA):

• ema_short_value, medium, long: ตำแหน่ง Y ของจุด EMA (เส้นสั้น, กลาง, ยาว) บนกราฟ
• ema_short_direction, medium, long: ทิศทางปัจจุบันของแต่ละเส้น ว่าเงยหน้าขึ้น ("Up"), ปักหัวลง ("Down"), ไซด์เวย์ ("Flat")
• ema_short_turn_type: รูปแบบการกลับตัวของเส้นสั้น ("TurnUp", "TurnDown", "-")
• ema_above, ema_long_above: เรียงลำดับว่าเส้นสั้นอยู่เหนือกลาง (ShortAbove) หรือกลางอยู่เหนือยาว (MediumAbove)

หมวดหมู่ MACD และอัตรถ่างขยาย (Convergence/Divergence):

• macd_12, macd_23: ความห่างระหว่างเส้น (เหมือน MACD Histogram ยิ่งมากยิ่งห่าง)
• previous_...: ค่าประวัติในแท่งก่อนหน้า เพื่อหาโมเมนตัมที่เปลี่ยนไป
• ema_convergence_type: โมเมนตัมระหว่างเส้นสั้นกับกลาง ("convergence" = ลู่เข้า, "divergence" = ถ่างกว้างขึ้นเรื่อยๆ, "neutral")
• ema_long_convergence_type: การลู่เข้า/ถ่างออกของเส้นกลางกับยาวย่อตัวอักษรเดียว ("C", "D", "N")

หมวดหมู่อินดิเคเตอร์วัดระดับ (Oscillators & Volatility):

• choppy_indicator: หาความผันผวนไซด์เวย์ (ยิ่งน้อยเทรนด์ยิ่งแข็ง, ยิ่งมากวิ่งไร้ทิศทาง)
• adx_value: วัดพลังสปีดของเทรนด์ (ถ้า > 25 แปลว่าวิ่งแรง)
• rsi_value: ดัชนีความแข็งของราคา ไว้หาจังหวะซื้อมากเกินไป (Overbought/Oversold)
• bb_values: { upper, middle, lower } เส้นตำแหน่งของ Bollinger Bands ทั้ง 3 เส้น
• bb_position: ราคาไปเกาะอยู่โซนไหนของ Band ("NearUpper", "NearLower", "Middle")
• atr: Average True Range วัดระยะทางเฉลี่ยที่แท่งเทียนสวิงตัว

หมวดหมู่อนาโตมีแท่งเทียนและความผิดปกติ (Anatomy & Abnormality):

• is_abnormal_candle: แท่งเทียนกระชากตัวรุนแรง (เทียบกับ ATR ส่วนใหญ่มักเกิดจากข่าวหลุด)
• is_abnormal_atr: ค่าแกว่งแท่งนั้นๆ มีปริมาณเนื้อแท่งมหาศาลหรือหดตัวรุนแรงกว่าปกติ
• u_wick, body, l_wick: ราคาจริงของไส้บน, ตัวเนื้อ, รถม้าล่าง
• u_wick_percent, body_percent, l_wick_percent: คิดเป็นตัวเลขกี่ % เมื่อนำความสูงเทียนไปหารกับขนาดทั้งดุ้น (สำคัญต่อสายหาแท่งหางยาว)

หมวดหมู่เส้นตัดทิศทาง (Crossings & Counters):

• ema_cut_position: จุดที่เส้นราคาตัดกับ EMA (เช่นทะลุตลอดตัว B1, ตัดปลาย 3,4 เป็นต้น)
• ema_cut_long_type: "UpTrend", "DownTrend" บอกสายลมหลัก
• candles_since_ema_cut: ผ่านมากี่แท่งหลังจากจุด Golden Cross (ถ้าน้อยกว่า 3 มักเป็นจุดเพิ่งเริ่มเทรนด์)
• up_con_medium_ema, down_con_medium_ema...: ดัชนีนับคอมโบ (Combo counters) ของเส้นที่ชี้ขึ้นกี่มัด ชี้ลงกี่มัดรวด

หมวดหมู่ Smart Money Concepts (SMC):

• smc.swing_trend, smc.internal_trend: เทรนด์ปัจจุบันของรอบใหญ่และรอบเล็ก ("bullish", "bearish", "neutral")
• smc.structures: อาร์เรย์เก็บประวัติการทำ Break of Structure (BOS) และ Change of Character (CHoCH)
• smc.swing_points: อาร์เรย์ระบุจุดกลับตัว High/Low (เช่น "HH" Higher-High, "LL" Lower-Low)
• smc.order_blocks: อาร์เรย์เก็บโซน Order Block (OB) ที่เกิดแท่งอิมบาลานซ์ ระบุเป็นกรอบราคา Upper-Lower
• smc.fair_value_gaps: อาร์เรย์เก็บโซน FVG (Fair Value Gap) หรือ Imbalance ที่รอราคาลงมาเติมเต็ม (Mitigate)
• smc.equal_highs_lows: อาร์เรย์เก็บคู่ยอดที่ทำ Equal Highs (EQH) ปลายแหลมสองยอด หรือ Equal Lows (EQL)
• smc.premium_discount_zone: ข้อมูลกล่องคำนวณแบ่งครึ่งราคา Premium โซนของแพงด้านบน / Discount โซนของถูกด้านล่าง
• smc.strong_weak_levels: แนวรับแข็ง/อ่อน (Strong/Weak High-Low) (โครงสร้างข้อมูล SMC ทั้งหมดนี้มีแบบเดียวกับไลบรารี SMCIndicator.js ฝั่ง Frontend)

หมวดหมู่รหัสสถานะ (Bot Configuration Codes):

• status_desc: "รหัสบรรทัดเดียวครอบจักรวาล" สูตรที่ขยำทุกอย่างมาบอกเช่น L-DU-U-R-C แปลความง่ายๆ = Mediumอยู่เหนือยาว(L), กลางลงแต่อุ้มสั้นขึ้น(DU), ยาวเชิดตรง(U), สีแดง(R), ถ่างออก(C)
• status_code: Code ตัวเลขเช่น "13", "25" ที่แปลงค่า Desc ให้เป็นเลขแมตช์เข้าตาราง
• is_mark, hint_status, suggest_color : ส่วนรองรับอื่นๆ ไว้ฉีดสัญญาณบอกผู้ใช้ในระบบ Frontend