redis学习笔记（8）---微线图sparkline

sparkline

　　微线图，即用一个一个信息点形成的图，类似于折线图。在表示时延的时候，就可以用微线图的形式来表示。

示例：

　　微线图中的信息点可以有两种形式：”_-`” 和 “_o#”

　　两种情况最后形成的微线图分别如下所示：

　　



　　

　　可以看到，用一个一个的信息点，非常形象明了的形成了所需的折线图

sparkline的实现

　　sparkline中每个信息点的定义为：

struct sample {
double value;
char *label;
};

　　value为该点的值

　　label为名称

　　而最终的微线图就是通过这样的信息点序列来实现的　　

struct sequence {
int length;
int labels;
struct sample *samples;
double min, max;
};

length：序列中的样点数

labels：序列中所有有标签的样点数

samples：数组，为组成微线图的样点集

min：所有样点中的最小值

max：所有样点中的最大值

创建一个微线图序列

struct sequence *createSparklineSequence(void) {
struct sequence *seq = zmalloc(sizeof(*seq));
seq->length = 0;
seq->samples = NULL;
return seq;
}

向微线图中加入一个样点

void sparklineSequenceAddSample(struct sequence *seq, double value, char *label) {
label = (label == NULL || label[0] == '\0') ? NULL : zstrdup(label);
if (seq->length == 0) {
seq->min = seq->max = value;
} else {  //更新最小值和最大值
if (value < seq->min) seq->min = value;
else if (value > seq->max) seq->max = value;
}
seq->samples = zrealloc(seq->samples,sizeof(struct sample)*(seq->length+1));
seq->samples[seq->length].value = value; //将样点加入到样点集中
seq->samples[seq->length].label = label;
seq->length++;
if (label) seq->labels++;
}

　　样点是按照一定顺序加入到序列集中的，因此最终形成的微线图中所有样点的x坐标都是按照先后顺序来依次递增的。

画图

sds sparklineRender(sds output, struct sequence *seq, int columns, int rows, int flags) {
int j;

for (j = 0; j < seq->length; j += columns) {
int sublen = (seq->length-j) < columns ? (seq->length-j) : columns;

if (j != 0) output = sdscatlen(output,"\n",1);
output = sparklineRenderRange(output, seq, rows, j, sublen, flags);
}
return output;
}

　　最终所有的样点是通过调用函数将每个样点转换为ASCII码形式，来形成最终的折线图的。

　　通过参数columns和rows限定了最后输出的图形的行数和列数，通过参数flags来选择每个信息点的表示方式。

　　当seq中样点数不大于限定的列数时，只需执行一次sparklineRenderRange（）就可以将序列中每个样点都转换为字符串的形式。

　　最后将输出的折线图按照字符串的形式存储在output中。 　　

//将seq中的seq->samples[offset,offset+len)的样点转换成rows行字符串的形式，存储在output中
sds sparklineRenderRange(sds output, struct sequence *seq, int rows, int offset, int len, int flags) {
int j;
double relmax = seq->max - seq->min; //最大相对值
int steps = charset_len*rows; //最终的行数
int row = 0;
char *chars = zmalloc(len);  //len列
int loop = 1;
int opt_fill = flags & SPARKLINE_FILL;
int opt_log = flags & SPARKLINE_LOG_SCALE;

if (opt_log) {
relmax = log(relmax+1);
} else if (relmax == 0) {
relmax = 1;
}

while(loop) {
loop = 0;
memset(chars,' ',len);
for (j = 0; j < len; j++) {
struct sample *s = &seq->samples[j+offset];
double relval = s->value - seq->min; //每个样点的相对值
int step;

if (opt_log) relval = log(relval+1);
step = (int) (relval*steps)/relmax;
if (step < 0) step = 0;
if (step >= steps) step = steps-1;

if (row < rows) {
int charidx = step-((rows-row-1)*charset_len);
loop = 1;
if (charidx >= 0 && charidx < charset_len) { //将数字转换为ASCII码
chars[j] = opt_fill ? charset_fill[charidx] :charset[charidx];
} else if(opt_fill && charidx >= charset_len) {
chars[j] = '|';
}
} else {  //对于大于row的行，不处理样点，只处理label
/* ......  */
}
}
if (loop) {
row++;
output = sdscatlen(output,chars,len);
output = sdscatlen(output,"\n",1);
}
}
zfree(chars);
return output;
}

　　这样就将一系列的样点值转换成ASCII码的字符串形式了

本文所引用的源码全部来自Redis3.0.7版本

redis学习参考资料：

https://github.com/huangz1990/redis-3.0-annotated

Redis 设计与实现（第二版）