AA_API void aa_cv_rgb2hsv(const double rgb[3], double hsv[3]) {
double r = rgb[0];
double g = rgb[1];
double b = rgb[2];
// using the polar coordinates method (not hexagon)
double alpha = 0.5 * (2*r - g - b);
double beta = (sqrt(3) / 2.0) * (g - b);
double c = sqrt(alpha*alpha + beta*beta);
// H
hsv[0] = atan2(beta, alpha);
// V
double tmp = AA_MAX(r,g);
hsv[2] = AA_MAX(tmp,b);
// S
if( aa_feq(c,0,0) ) {
hsv[1] = 0;
} else {
hsv[1] = c / hsv[2];
}
}
/// Deadzone Damped Pseudoinverse
void aa_la_dzdpinv( size_t m, size_t n, double s2_min, const double *A, double *A_star ) {
// A^T (AA^T + kI)^{-1}
// A is m*n
// x = Aq, x is m, q is n
const int mi = (int)m;
const int ni = (int)n;
// This method uses the SVD
double *W = (double*)aa_mem_region_local_alloc( sizeof(double) *
(m*m + n*n + AA_MIN(m,n)) );
double *U = W; // size m*m
double *Vt = U + m*m; // size n*n
double *S = Vt + n*n; // size min(m,n)
// A = U S V^T
aa_la_svd(m,n,A,U,S,Vt);
memset( A_star, 0, sizeof(double)*m*n );
// \sum s_i/(s_i**2+k) * v_i * u_i^T
for( size_t i = 0; i < AA_MIN(m,n); i ++ ) {
double s2 = AA_MAX( (S[i]*S[i]), s2_min );
cblas_dger( CblasColMajor, ni, mi, S[i] / s2,
Vt + i, ni,
U + m*i, 1,
A_star, ni
);
}
aa_mem_region_local_pop( W );
}
AA_API ssize_t aa_read_realloc(int fd, void **buf,
size_t off, size_t *max) {
size_t n = *max - off;
if( n < 16 ) {
*max = AA_MAX( 2*(*max), (size_t)16 );
*buf = realloc(*buf, *max);
n = *max - off;
}
return read( fd, ((uint8_t*)*buf)+off, n );
}
static void aa_mem_region_grow( aa_mem_region_t *reg, size_t size ) {
size_t nsize = AA_MAX(2*(size_t)(reg->node->end - reg->node->d),
size + AA_MEMREG_ALIGN);
// this growth strategy creates worst-case O(n) memory waste
reg->node =
aa_mem_region_node_alloc( nsize,
/* free unused chunk */
(aa_mem_region_alignptr(reg->node->d) == reg->head) ?
aa_mem_region_node_free(reg->node) : reg->node );
aa_mem_region_align(reg, reg->node->d);
assert( aa_mem_region_freesize(reg) >= size );
assert( ! ((uintptr_t)reg->head%16) );
}
void aa_mem_pool_init( aa_mem_pool_t *pool, size_t size, size_t count ) {
pool->size = AA_MAX(size,(size_t)16);
pool->top = NULL;
aa_mem_region_init( &pool->region, pool->size * count );
}
double aa_la_max( size_t n, const double *x ) {
double v = -HUGE_VAL;
for( size_t i = 0; i < n; i++ )
v = AA_MAX(v,x[i]);
return v;
}
