From Tick to K-Line: Data Conversion and Calculation Methods

K-line charts (candlestick charts) are a commonly used chart type in stock markets and financial trading, used to display information such as the opening price, highest price, lowest price, and closing price over a period of time. This article introduces how to convert real-time tick data into K-line data of different timeframes, and provides the necessary formulas and calculation methods to help you better analyze and understand market trends.

1. Introduction to K-Line Charts

A K-line chart consists of a series of consecutive rectangular bars, each representing the price movement over a specific time period. Each rectangular bar typically contains four key price points: Open, High, Low, and Close. The shapes and combinations of K-lines help analysts and traders identify market trends and price patterns.

2. Real-Time Tick Data

Real-time tick data refers to the price and volume information of each individual trade in the market. It provides immediate feedback on market liquidity and price changes. Real-time tick data usually contains fields such as timestamp, traded price, and traded volume.

3. Calculation Method for K-Line Data

Time Window Setting
First, you need to determine the timeframe of the K-line, i.e., the time period each K-line represents, such as 1 minute, 15 minutes, 1 hour, etc. This defines the sampling interval for the real-time tick data.

K-Line Data Calculation
Within each time window, calculate the price points of the K-line from the real-time tick data:

• Open: The price of the first tick in the time window.
• High: The highest price within the time window.
• Low: The lowest price within the time window.
• Close: The price of the last tick in the time window.

Updating K-Line Data
As time progresses, each time window slides, and new tick data enters the calculation range. At the end of each time window, update the K-line data based on the new tick data.

Calculating Other Indicators
In addition to Open, High, Low, and Close, you can also calculate other indicators from the K-line data, such as volume, moving averages, etc. These indicators can provide deeper market analysis.

4. Example Formula

Below is an example showing how to convert real-time tick data into 1‑minute K‑line data:

1. Initialize K-line data:
   • Initial Open: price of the first tick
   • Initial High: price of the first tick
   • Initial Low: price of the first tick
   • Initial Close: price of the first tick
2. Update K-line data:
   • If the timestamp of the current tick is not within the current time window, it means the time window has ended, and the K‑line data should be updated.
   • Update Open: Close price of the previous time window (Previous Close)
   • Update High: highest price within the time window
   • Update Low: lowest price within the time window
   • Update Close: price of the current tick

The above is a simple example; in practice, more details and data processing methods may need to be considered to meet specific requirements.

Java Code Example

import java.util.ArrayList;
import java.util.List;

public class KLineGenerator {
public static List<KLineData> generateKLineData(List<TickData> tickDataList, int interval) {
List<KLineData> kLineDataList = new ArrayList<>();
long startTime = tickDataList.get(0).getTime(); // Get the first tick's time as start time

// Initialize K-line data
long currentKLineStartTime = startTime - (startTime % interval);
double openPrice = tickDataList.get(0).getPrice();
double highPrice = openPrice;
double lowPrice = openPrice;
double closePrice = 0;
long volume = 0;

// Iterate through tick data
for (TickData tickData : tickDataList) {
long currentTime = tickData.getTime();
double currentPrice = tickData.getPrice();
long currentVolume = tickData.getVolume();

// If beyond the current K-line time period, generate a new K-line
if (currentTime >= currentKLineStartTime + interval) {
closePrice = tickDataList.get(tickDataList.indexOf(tickData) - 1).getPrice(); // previous tick's price as close

KLineData kLineData = new KLineData(currentKLineStartTime, openPrice, highPrice, lowPrice, closePrice, volume);
kLineDataList.add(kLineData);

// Reset K-line data for the new time period
currentKLineStartTime += interval;
openPrice = currentPrice;
highPrice = currentPrice;
lowPrice = currentPrice;
volume = currentVolume;
} else {
// Update K-line data
highPrice = Math.max(highPrice, currentPrice);
lowPrice = Math.min(lowPrice, currentPrice);
volume += currentVolume;
}
}

// Last tick's price as close
closePrice = tickDataList.get(tickDataList.size() - 1).getPrice();

// Generate the last K-line
KLineData lastKLineData = new KLineData(currentKLineStartTime, openPrice, highPrice, lowPrice, closePrice, volume);
kLineDataList.add(lastKLineData);

return kLineDataList;
}
}



// Tick data class
class TickData {
private long time;
private double price;
private long volume;

public TickData(long time, double price, long volume) {
this.time = time;
this.price = price;
this.volume = volume;
}

public long getTime() { return time; }
public double getPrice() { return price; }
public long getVolume() { return volume; }
}

// K-line data class
class KLineData {
private long time;
private double open;
private double high;
private double low;
private double close;
private long volume;

public KLineData(long time, double open, double high, double low, double close, long volume) {
this.time = time;
this.open = open;
this.high = high;
this.low = low;
this.close = close;
this.volume = volume;
}
// Getters and setters omitted
}

Python Code Example

from datetime import datetime, timedelta

class TickData:
def __init__(self, time, price, volume):
self.time = time
self.price = price
self.volume = volume

class KLineData:
def __init__(self, time, open_price, high_price, low_price, close_price, volume):
self.time = time
self.open_price = open_price
self.high_price = high_price
self.low_price = low_price
self.close_price = close_price
self.volume = volume

def generate_kline_data(tick_data_list, interval):
kline_data_list = []
start_time = tick_data_list[0].time
current_kline_start_time = start_time - (start_time % interval)
open_price = tick_data_list[0].price
high_price = open_price
low_price = open_price
close_price = 0
volume = 0

for tick_data in tick_data_list:
current_time = tick_data.time
current_price = tick_data.price
current_volume = tick_data.volume

if current_time >= current_kline_start_time + interval:
close_price = tick_data_list[tick_data_list.index(tick_data) - 1].price
kline_data = KLineData(current_kline_start_time, open_price, high_price, low_price, close_price, volume)
kline_data_list.append(kline_data)

current_kline_start_time += interval
open_price = current_price
high_price = current_price
low_price = current_price
volume = current_volume
else:
high_price = max(high_price, current_price)
low_price = min(low_price, current_price)
volume += current_volume

close_price = tick_data_list[-1].price
last_kline_data = KLineData(current_kline_start_time, open_price, high_price, low_price, close_price, volume)
kline_data_list.append(last_kline_data)

return kline_data_list