void name(const std::string& value) { _set("name", value); }
void resptrcode_texture::create(LPCSTR _name)
{
_set(DEV->_CreateTexture(_name));
}
void vgroup(const std::string& value) { _set("vgroup", value); }
void resptrcode_geom::create (D3DVERTEXELEMENT9* decl, IDirect3DVertexBuffer9* vb, IDirect3DIndexBuffer9* ib)
{
_set(Device.Resources->CreateGeom (decl,vb,ib));
}
inline void set(const double *inp, int inp_num) {
if (inp == NULL || inp_num < 0) {
throw new AzException("AzDvect::set(array)", "Invalid input");
}
_set(inp, inp_num);
}
void ip_addr(const std::string& value) { _set("ip_addr", value); }
void resptrcode_shader::create (IBlender* B, LPCSTR s_shader, LPCSTR s_textures, LPCSTR s_constants, LPCSTR s_matrices)
{
_set(Device.Resources->Create (B,s_shader,s_textures,s_constants,s_matrices));
}
void Layer::set(const int x, const int y, const Uint32 tid) {
_set(_w * y + x, tid);
}
bool MedianFilter::_filter(const T *in, T *out)
{
uint s = _size.width*_size.height;
T *cur, *hist;
if(_current.size() != s*sizeof(T))
{
_current.resize(s*sizeof(T));
memset(_current.data(), 0, s*sizeof(T));
}
uint histSize = (2*_halfKernelSize + 1)*(2*_halfKernelSize + 1);
if(_hist.size() != histSize*sizeof(T))
{
_hist.resize(histSize*sizeof(T));
memset(_hist.data(), 0, histSize*sizeof(T));
}
cur = (T *)_current.data();
hist = (T *)_hist.data();
int stablePixel = _size.width*_size.height;
int index;
for (int j = 0; j < _size.height; j++)
{
for (int i = 0; i < _size.width; i++)
{
int p = j*_size.width + i;
index = 0;
for (int k = -(int)_halfKernelSize; k <= (int)_halfKernelSize; k++)
{
for (int m = -(int)_halfKernelSize; m <= (int)_halfKernelSize; m++)
{
int i2 = i+m; int j2 = j+k;
if ((j2 >= 0 && j2 < _size.height) && (i2 >= 0 && i2 < _size.width))
{
int q = j2*_size.width+i2;
hist[index++] = in[q];
}
}
}
std::nth_element(hist, hist + index/2, hist + index);
T val = hist[index/2];
// Output w/ deadband
float ferr = cur[p]?fabs((float)(val- cur[p])/cur[p]):FLT_MAX;
if (ferr > _deadband)
{
out[p] = cur[p] = val;
stablePixel--;
}
else
out[p] = cur[p];
} // for (i)
} // for (j)
// Adjust deadband until ratio is achieved
float diff = (float)stablePixel - _stability*_size.width*_size.height;
if (diff < 0)
_deadband += _deadbandStep;
else
_deadband -= _deadbandStep;
_set("deadband", _deadband);
return true;
}
void ILowLineBars::_calculate(const Indicator& ind) {
size_t total = ind.size();
if (0 == total) {
m_discard = 0;
return;
}
if (ind.discard() >= total) {
m_discard = total;
return;
}
m_discard = ind.discard();
if (1 == total) {
if (0 == m_discard) {
_set(0, 0);
}
return;
}
int n = getParam<int>("n");
if (0 == n) {
n = total - m_discard;
} else if (n > total) {
n = total;
}
price_t min = ind[m_discard];
size_t pre_pos = m_discard;
size_t start_pos = m_discard + n < total ? m_discard + n : total;
for (size_t i = m_discard; i < start_pos; i++) {
if (ind[i] <= min) {
min = ind[i];
pre_pos = i;
}
_set(i - pre_pos, i);
}
for (size_t i = start_pos; i < total-1; i++) {
size_t j = i + 1 - n;
if (pre_pos < j) {
pre_pos = j;
min = ind[j];
}
if (ind[i] <= min) {
min = ind[i];
pre_pos = i;
}
_set(i - pre_pos, i);
}
start_pos = total - n;
min = ind[start_pos];
pre_pos = start_pos;
for (size_t i = start_pos; i < total; i++) {
if (ind[i] <= min) {
pre_pos = i;
min = ind[i];
}
}
_set(total-pre_pos-1, total-1);
}
void resptrcode_crt::create(LPCSTR Name, u32 w, u32 h, D3DFORMAT f, u32 SampleCount)
{
_set (DEV->_CreateRT(Name,w,h,f, SampleCount));
}
QJSValue THREEVector3::set(float x, float y, float z) {
return m_engine->newQObject(_set(x, y, z));
}
bstnode * bst_set(bstnode *root, char * key, void * val, size_t size) {
return _set(root, key, val, size, SET);
}
bstnode * bst_add(bstnode *root, char * key, void * val, size_t size) {
return _set(root, key, val, size, ADD);
}
void value(const std::string& value) { _set("value", value); }
void protocol(const std::string& value) { _set("protocol", value); }
void hostname(const std::string& value) { _set("hostname", value); }
void src_port(const std::string& value) { _set("src_port", value); }
void mac_addr(const std::string& value) { _set("mac_addr", value); }
void port_range(const std::string& value) { _set("port_range", value); }
void resptrcode_geom::create (u32 FVF , IDirect3DVertexBuffer9* vb, IDirect3DIndexBuffer9* ib)
{
_set(Device.Resources->CreateGeom (FVF,vb,ib));
}
void dst_addr(const std::string& value) { _set("dst_addr", value); }
void Mem::_zero(void *mem, SIZE_T size)
{
_set(mem, 0, size);
}
void dst_port(const std::string& value) { _set("dst_port", value); }
inline void set(const AzDvect *inp, double coeff=1) {
_set(inp->elm, inp->num);
if (coeff != 1) multiply(coeff);
}
/*
* creat a leaf node and its branch point.
* then, insert the branch point as the parent of the specified node.
*/
static anode_t *
_alloc(aguri_t *tp, const void *key, anode_t *np) {
anode_t *bp = NULL, *leaf = NULL;
/* reclaim two nodes from the LRU list */
leaf = TAILQ_LAST(&tp->tr_lru, _lru);
while (leaf->tn_intree)
leaf = TAILQ_PREV(leaf, _lru, tn_chain);
TAILQ_REMOVE(&tp->tr_lru, leaf, tn_chain);
TAILQ_INSERT_HEAD(&tp->tr_lru, leaf, tn_chain);
leaf->tn_intree = 1;
tp->tr_nfree--;
_nreset(leaf);
memcpy(leaf->tn_key, key, tp->tr_keylen/8);
leaf->tn_prefixlen = tp->tr_keylen;
assert(tp->tr_nfree > 0);
bp = TAILQ_LAST(&tp->tr_lru, _lru);
while (bp->tn_intree)
bp = TAILQ_PREV(bp, _lru, tn_chain);
TAILQ_REMOVE(&tp->tr_lru, bp, tn_chain);
bp->tn_intree = 1;
tp->tr_nfree--;
_nreset(bp);
bp->tn_prefixlen = _common(np->tn_key, key, tp->tr_keylen, bp->tn_key);
if (bp->tn_prefixlen >= np->tn_prefixlen) {
/*
* leaf should be a child of np
*/
assert(np->tn_left == NULL && np->tn_right == NULL);
TAILQ_REMOVE(&tp->tr_lru, np, tn_chain);
TAILQ_INSERT_HEAD(&tp->tr_lru, bp, tn_chain);
if (bp->tn_prefixlen != np->tn_prefixlen) {
_set(bp->tn_key, np->tn_prefixlen + 1);
np->tn_left = leaf;
np->tn_right = bp;
} else {
np->tn_left = bp;
np->tn_right = leaf;
}
bp->tn_parent = np;
leaf->tn_parent = np;
return (leaf);
}
if (np->tn_parent->tn_left == np)
np->tn_parent->tn_left = bp;
else
np->tn_parent->tn_right = bp;
bp->tn_parent = np->tn_parent;
if (_isset(key, bp->tn_prefixlen + 1)) {
bp->tn_left = np;
bp->tn_right = leaf;
} else {
bp->tn_left = leaf;
bp->tn_right = np;
}
np->tn_parent = bp;
leaf->tn_parent = bp;
return (leaf);
}
