void rs_gen_func_normalize(int dest, float vmin, float vmax) {
// LAGGY !!!!!!!!!!!!!
float val_min = rs_gen_reg.tex[dest*rs_gen_reg.tex_length];
float val_max = rs_gen_reg.tex[dest*rs_gen_reg.tex_length];
float f;
int i, j;
for (i = 0; i < rs_gen_reg.tex_size; i++) {
for (j = 0; j < rs_gen_reg.tex_size; j++) {
f = rs_gen_reg.tex[dest*rs_gen_reg.tex_length + i*rs_gen_reg.tex_size + j] ;
val_max = rs_max(val_max, f);
val_min = rs_min(val_min, f);
};
};
float val_scale = (vmax - vmin) / (val_max - val_min) - vmin;
for (i = 0; i < rs_gen_reg.tex_size; i++) {
for (j = 0; j < rs_gen_reg.tex_size; j++) {
rs_gen_reg.tex[dest*rs_gen_reg.tex_length + i*rs_gen_reg.tex_size + j] =
vmin + val_scale * ( rs_gen_reg.tex[dest*rs_gen_reg.tex_length + i*rs_gen_reg.tex_size + j] - val_min);
};
};
};
char *rs_strerror(rs_err_t err, char *errstr, size_t size)
{
char *msg;
msg = ((uint32_t) err < RS_SYS_NERR) ? rs_sys_errlist[err]
: rs_unknown_error; // not modify
size = rs_min(size, rs_strlen(msg));
return rs_cpymem(errstr, msg, size);
}
int rs_binlog_query_handler(rs_reqdump_data_t *rd)
{
int r;
rs_binlog_info_t *bi;
char query[rd->binlog_info.dl], *p;
bi = &(rd->binlog_info);
p = query;
if(bi->dl > RS_SQL_MAX_LEN * 2) {
bi->skip = 1;
return RS_OK;
}
/* get query event fixed data */
if((r = rs_eof_read_binlog2(rd, query, bi->dl)) != RS_OK)
{
return r;
}
/* seek after flags and unwant fixed data */
p += RS_BINLOG_QUERY_THREAD_ID_LEN + RS_BINLOG_QUERY_EXEC_SEC_LEN;
/* get database name len */
rs_memcpy(&(bi->dbl), p, RS_BINLOG_QUERY_DB_NAME_LEN);
bi->dbl = (bi->dbl & 0x000000FF) + 1;
p += RS_BINLOG_QUERY_DB_NAME_LEN + RS_BINLOG_QUERY_ERR_CODE_LEN;
/* get status block len */
rs_memcpy(&(bi->sbl), p, RS_BINLOG_QUERY_STAT_BLOCK_LEN);
bi->sbl = bi->sbl & 0x0000FFFF;
p += RS_BINLOG_QUERY_STAT_BLOCK_LEN + bi->sbl;
/* get database name */
rs_memcpy(bi->db, p, bi->dbl);
p += bi->dbl;
/* filter care about list */
bi->sl = bi->el - RS_BINLOG_EVENT_HEADER_LEN - bi->sbl -
RS_BINLOG_QUERY_FIXED_DATA_LEN - bi->dbl;
bi->sl = rs_min(RS_SQL_MAX_LEN, bi->sl);
rs_memcpy(bi->sql, p, bi->sl);
bi->sql[bi->sl] = '\0';
bi->log_format = RS_BINLOG_FORMAT_SQL_STATEMENT;
rs_log_debug(RS_DEBUG_BINLOG, 0,
"\ndatabase name : %s\n"
"query sql : %s\n"
"next position : %u\n",
bi->db,
bi->sql,
bi->np
);
if(rs_strncmp(bi->sql, RS_TRAN_KEYWORD, RS_TRAN_KEYWORD_LEN) == 0) {
bi->tran = 1;
} else if(rs_strncmp(bi->sql, RS_TRAN_END_KEYWORD,
RS_TRAN_END_KEYWORD_LEN) == 0) {
bi->tran = 0;
} else {
}
return RS_OK;
}
double sunlit_stomata_conductance () const
{ return 1.0 / rs_min (); }
double shadow_stomata_conductance () const
{ return 1.0 / rs_min (); }
int rs_eof_read_binlog2(rs_reqdump_data_t *rd, void *buf, size_t size)
{
int wd1, wd2, err, r;
size_t ms, n, ls, tl;
ssize_t l;
struct inotify_event *e;
char eb[1024], *p, *f;
n = 0;
wd1 = -1;
wd2 = -2;
f = buf;
r = RS_ERR;
ms = rs_min((uint32_t) (rd->io_buf->last - rd->io_buf->pos), size);
/* use io_buf */
if(ms > 0) {
f = rs_cpymem(f, rd->io_buf->pos, ms);
rd->io_buf->pos += ms;
}
while(ms < size) {
/* feed io_buf */
n = fread(rd->io_buf->start, 1, rd->io_buf->size, rd->binlog_fp);
if(n > 0) {
ls = rs_min(n, size - ms);
f = rs_cpymem(f, rd->io_buf->start, ls);
rd->io_buf->pos = rd->io_buf->start + ls;
rd->io_buf->last = rd->io_buf->start + n;
ms += ls;
} else {
if(feof(rd->binlog_fp) == 0) {
if((err = ferror(rd->binlog_fp)) != 0) {
/* file error */
rs_log_error(RS_LOG_ERR, err, "ferror(\"%s\") failed",
rd->dump_file);
goto free;
}
}
/* set inotify */
if(rd->notify_fd == -1) {
rd->notify_fd = rs_init_io_watch();
if(rd->notify_fd < 0) {
goto free;
}
wd1 = rs_add_io_watch(rd->notify_fd, rd->dump_file,
RS_IN_MODIFY);
wd2 = inotify_add_watch(rd->notify_fd,
rs_master_info->binlog_idx_file, RS_IN_MODIFY);
if(wd1 < 0 || wd2 < 0) {
goto free;
}
}
/* test has binlog */
if((err = rs_has_next_binlog(rd)) == RS_OK) {
r = RS_HAS_BINLOG;
goto free;
}
if(err == RS_ERR) {
goto free;
}
/* sleep wait, release cpu */
err = rs_timed_select(rd->notify_fd, RS_BINLOG_EOF_WAIT_SEC, 0);
if(err == RS_ERR) {
goto free;
} else if(err == RS_TIMEDOUT) {
continue;
}
l = rs_read(rd->notify_fd, eb, 1024);
if(l <= 0) {
goto free;
}
p = eb;
e = (struct inotify_event *) eb;
if(e == NULL) {
goto free;
}
while (((char *) e - eb) < l) {
if (e->wd == wd1 && e->mask & RS_IN_MODIFY) {
break;
} else if(e->wd == wd2 && e->mask & RS_IN_MODIFY) {
break;
}
tl = sizeof(struct inotify_event) + e->len;
e = (struct inotify_event *) (p + tl);
if(e == NULL) {
break;
}
p += tl;
} // end while
}
}
r = RS_OK;
clearerr(rd->binlog_fp);
free:
if(rd->notify_fd != -1) {
if(close(rd->notify_fd) != 0) {
rs_log_error(RS_LOG_ERR, rs_errno, "close() failed");
r = RS_ERR;
}
rd->notify_fd = -1;
}
return r;
}
void TransformMesh::Initialize(int gridSize, int minGridSize, double gridSizeOverrideRatio,
RS_Bounds& srcExt, int srcW, int srcH,
RS_Bounds& destExt, int destW, int destH,
CSysTransformer* xformer,
bool invertYaxis)
{
_ASSERT(xformer != NULL);
_ASSERT(gridSize > 0 && minGridSize > 0 && srcW > 0 && srcH > 0 && destW > 0 && destH > 0);
_ASSERT(gridSizeOverrideRatio >= MIN_GRID_SIZE_OVERRIDE_RATIO && gridSizeOverrideRatio <= MAX_GRID_SIZE_OVERRIDE_RATIO);
// initialize members
m_minGridSize = minGridSize;
m_gridSizeOverrideRatio = gridSizeOverrideRatio;
int calculatedGridSize = gridSize;
// if the override is enabled (0 < ratio < 1), then adjust if necessary
if (gridSizeOverrideRatio < MAX_GRID_SIZE_OVERRIDE_RATIO
&& gridSizeOverrideRatio > MIN_GRID_SIZE_OVERRIDE_RATIO)
{
// the calculated grid size is the minimum of the passed in grid size and the overrided grid size
calculatedGridSize = rs_min(gridSize, (int)(rs_min(srcH, srcW) * m_gridSizeOverrideRatio));
}
// we check to make sure the minGridSize is less that gridSize
// -- in case we are given a minGridSize that is greater than the gridSize
// ensure grid size is not less than the minimum
if (minGridSize < gridSize)
{
calculatedGridSize = rs_max(minGridSize, calculatedGridSize);
}
// ensure grid size is not bigger than the source image's height and width
m_gridSizeHeight = rs_min(calculatedGridSize, srcH);
m_gridSizeWidth = rs_min(calculatedGridSize, srcW);
m_yAxisInverted = invertYaxis;
m_meshPoints.empty();
m_numVerticalPoints = 0;
m_numHorizontalPoints = 0;
double pixPerSrcUnitX = (double)srcW / srcExt.width();
double pixPerSrcUnitY = (double)srcH / srcExt.height();
double pixPerDestUnitX = (double)destW / destExt.width();
double pixPerDestUnitY = (double)destH / destExt.height();
// Create a grid in pixel space that covers the whole src extent
for (int gridX = 0; gridX < srcW + m_gridSizeWidth; gridX += m_gridSizeWidth)
{
++m_numHorizontalPoints;
// this sets the x-coordinate to the end pt if it gets close
if (gridX + MAX_GRID_EXPANSION_FACTOR * m_gridSizeWidth > srcW || gridX > srcW)
{
gridX = srcW;
}
for (int gridY = 0; gridY < srcH + m_gridSizeHeight; gridY += m_gridSizeHeight)
{
if (gridX == 0)
++m_numVerticalPoints;
// this sets the y-coordinate to the end pt if it gets close
if (gridY + MAX_GRID_EXPANSION_FACTOR * m_gridSizeHeight > srcH || gridY > srcH)
gridY = srcH;
// The point in pixel coordinates in the src image
RS_F_Point src_pt0(gridX, gridY);
// Convert from screen coordinates to src CS coordinates (note that the screen coords are inverted because the
// invert y axis based upon the setting
RS_F_Point srcCS_pt0(src_pt0.x / pixPerSrcUnitX + srcExt.minx,
(m_yAxisInverted ? (srcH - src_pt0.y) : src_pt0.y) / pixPerSrcUnitY + srcExt.miny);
// Convert from src cs to dest cs coordinates
RS_F_Point destCS_pt0(srcCS_pt0.x, srcCS_pt0.y);
xformer->TransformPoint(destCS_pt0.x, destCS_pt0.y);
// Convert from dest CS coordinates to dest pixel coordinates.
RS_F_Point dest_pt0((destCS_pt0.x - destExt.minx) * pixPerDestUnitX,
(destCS_pt0.y - destExt.miny) * pixPerDestUnitY);
// Store the point mapping in the transform mesh
MeshPoint mesh_pt;
mesh_pt.pt_src = src_pt0;
mesh_pt.pt_dest = dest_pt0;
m_meshPoints.push_back(mesh_pt);
}
}
}
void rs_gen_func_normalmap(int dest_r, int dest_g, int dest_b, int src, float k) {
int i, j;
float max_val = -111111.0;
float min_val = 100000.0;
for (i = 0; i < rs_gen_reg.tex_size; i++) {
for (j = 0; j < rs_gen_reg.tex_size; j++) {
unsigned short um = rs_gen_reg.tex_size + j-2;
unsigned short vm = rs_gen_reg.tex_size + i-2;
unsigned short u = j;
unsigned short v = i;
unsigned short up = j+2;
unsigned short vp = i+2;
um %= rs_gen_reg.tex_size;
vm %= rs_gen_reg.tex_size;
up %= rs_gen_reg.tex_size;
vp %= rs_gen_reg.tex_size;
// float val1 = rs_gen_reg.tex[src*rs_gen_reg.tex_length + v*rs_gen_reg.tex_size + u];
float val_xp = 2.0 * rs_gen_reg.tex[src*rs_gen_reg.tex_length + v*rs_gen_reg.tex_size + up]
+ rs_gen_reg.tex[src*rs_gen_reg.tex_length + vm*rs_gen_reg.tex_size + up]
+ rs_gen_reg.tex[src*rs_gen_reg.tex_length + vp*rs_gen_reg.tex_size + up];
float val_xm = 2.0 * rs_gen_reg.tex[src*rs_gen_reg.tex_length + v*rs_gen_reg.tex_size + um]
+ rs_gen_reg.tex[src*rs_gen_reg.tex_length + vm*rs_gen_reg.tex_size + um]
+ rs_gen_reg.tex[src*rs_gen_reg.tex_length + vp*rs_gen_reg.tex_size + um];
float val_yp = 2.0 * rs_gen_reg.tex[src*rs_gen_reg.tex_length + vp*rs_gen_reg.tex_size + u]
+ rs_gen_reg.tex[src*rs_gen_reg.tex_length + vp*rs_gen_reg.tex_size + um]
+ rs_gen_reg.tex[src*rs_gen_reg.tex_length + vp*rs_gen_reg.tex_size + up];
float val_ym = 2.0 * rs_gen_reg.tex[src*rs_gen_reg.tex_length + vm*rs_gen_reg.tex_size + u]
+ rs_gen_reg.tex[src*rs_gen_reg.tex_length + vm*rs_gen_reg.tex_size + um]
+ rs_gen_reg.tex[src*rs_gen_reg.tex_length + vm*rs_gen_reg.tex_size + up];
// float val_dx = rs_gen_reg.tex[src*rs_gen_reg.tex_length + v*rs_gen_reg.tex_size + u2] - val1;
// float val_dy = rs_gen_reg.tex[src*rs_gen_reg.tex_length + v2*rs_gen_reg.tex_size + u] - val1;
float val_dx = val_xp - val_xm;
float val_dy = val_yp - val_ym;
// val_dx = val_dx;
// val_dy = -val_dy;
// val_dx = atan(val_dx * rs_gen_reg.tex_size ) / (M_PI/2);
// val_dy = atan(val_dy * rs_gen_reg.tex_size ) / (M_PI/2);
float bump_scale = 128.0 / rs_gen_reg.tex_size / k;
rs_vec3_t bump = rs_vec3_cross( rs_vec3_normalize(rs_vec3(bump_scale, 0.0, val_dy)),
rs_vec3_normalize(rs_vec3(0.0, bump_scale, -val_dx)));
float val_dz = sqrtf( 1.0 - (RS_SQR(k*val_dx) + RS_SQR(k*val_dy)) );
// val_dz = val_dz;
// val_dz = 1.0 / 2.0;
val_dx = 0.5 + 0.5*val_dx;
val_dy = 0.5 + 0.5*val_dy;
val_dz = 0.5 + 0.5*val_dz;
max_val = rs_max(max_val, fabs(val_dx) );
// max_val = rs_max(max_val, fabs(val_dy) );
min_val = rs_min(min_val, val_dx);
// min_val = rs_min(min_val, val_dy);
// rs_gen_reg.tex[dest_r*rs_gen_reg.tex_length + i*rs_gen_reg.tex_size + j] = val_dy;
// rs_gen_reg.tex[dest_g*rs_gen_reg.tex_length + i*rs_gen_reg.tex_size + j] = val_dx;
// rs_gen_reg.tex[dest_b*rs_gen_reg.tex_length + i*rs_gen_reg.tex_size + j] = val_dz;
rs_gen_reg.tex[dest_r*rs_gen_reg.tex_length + i*rs_gen_reg.tex_size + j] = 0.5 + 0.5*bump.x;
rs_gen_reg.tex[dest_g*rs_gen_reg.tex_length + i*rs_gen_reg.tex_size + j] = 0.5 + 0.5*bump.y;
rs_gen_reg.tex[dest_b*rs_gen_reg.tex_length + i*rs_gen_reg.tex_size + j] = 0.5 + 0.5*bump.z;
};
};
////// if (max_val < 0.001) {
////// DEBUG10f("WARNING, max_val of normalmap is too low (%.9f) \n", max_val);
////// max_val = 0.001;
////// };
//////
////// max_val *= 1.0;
//////
////// for (i = 0; i < rs_gen_reg.tex_size; i++) {
////// for (j = 0; j < rs_gen_reg.tex_size; j++) {
//////
////// rs_gen_reg.tex[dest_r*rs_gen_reg.tex_length + i*rs_gen_reg.tex_size + j] /= max_val;
////// rs_gen_reg.tex[dest_g*rs_gen_reg.tex_length + i*rs_gen_reg.tex_size + j] /= max_val;
//////
////// rs_gen_reg.tex[dest_b*rs_gen_reg.tex_length + i*rs_gen_reg.tex_size + j] =
////// sqrtf( 1.0 - (RS_SQR(rs_gen_reg.tex[dest_r*rs_gen_reg.tex_length + i*rs_gen_reg.tex_size + j])
////// + RS_SQR(rs_gen_reg.tex[dest_g*rs_gen_reg.tex_length + i*rs_gen_reg.tex_size + j])) );
//////
//////
////// rs_gen_reg.tex[dest_r*rs_gen_reg.tex_length + i*rs_gen_reg.tex_size + j] =
////// 0.5 + 0.5*rs_gen_reg.tex[dest_r*rs_gen_reg.tex_length + i*rs_gen_reg.tex_size + j];
////// rs_gen_reg.tex[dest_g*rs_gen_reg.tex_length + i*rs_gen_reg.tex_size + j] =
////// 0.5 + 0.5*rs_gen_reg.tex[dest_g*rs_gen_reg.tex_length + i*rs_gen_reg.tex_size + j];
//////
//////
//////// float val_dx = rs_gen_reg.tex[dest_r*rs_gen_reg.tex_length + i*rs_gen_reg.tex_size + j];
//////// float val_dy = rs_gen_reg.tex[dest_g*rs_gen_reg.tex_length + i*rs_gen_reg.tex_size + j];
////////
//////// float val_dz = sqrtf( 1.0 - (RS_SQR(k*val_dx) + RS_SQR(k*val_dy)) );
//////
//////// val_dx = 0.5 + 0.5*k*val_dx;
//////// val_dy = 0.5 + 0.5*k*val_dy;
//////// val_dz = 0.5 + 0.5*val_dz;
//////
//////
////// //rs_gen_reg.tex[dest_b*rs_gen_reg.tex_length + i*rs_gen_reg.tex_size + j] = val_dz;
//////
////// };
////// };
// DEBUG10f("\n\nmax val %.3f \nmin %.3f \n", max_val, min_val);
};
