/*
* call-seq:
*
*
* From: https://code.ros.org/trac/opencv/browser/trunk/opencv/samples/c/find_obj.cpp?rev=2065
*/
VALUE
rb_flann(VALUE klass, VALUE objectDesc, VALUE imageDesc)
{
const cv::Mat m_object(CVMAT(objectDesc));
const cv::Mat m_image(CVMAT(imageDesc));
cv::Mat m_indices(m_object.rows, 2, CV_32S);
cv::Mat m_dists(m_object.rows, 2, CV_32F);
cv::flann::Index flann_index(m_image, cv::flann::KDTreeIndexParams(4)); // using 4 randomized kdtrees
flann_index.knnSearch(m_object, m_indices, m_dists, 2, cv::flann::SearchParams(64)); // maximum number of leafs checked
VALUE ptpairs = rb_ary_new();
int* indices_ptr = m_indices.ptr<int>(0);
float* dists_ptr = m_dists.ptr<float>(0);
for (int i = 0; i < m_indices.rows; ++i) {
if (dists_ptr[2 * i] < 0.6 * dists_ptr[2 * i + 1]) {
rb_ary_push(ptpairs, rb_int_new(i));
rb_ary_push(ptpairs, rb_int_new(indices_ptr[2 * i]));
}
}
return ptpairs;
}
/** Yields an entity's language, id, start, and end position to a required Ruby block */
void ragel_parse_yield_entity(const char *lang, const char *entity, int s, int e) {
if (rb_block_given_p()) {
VALUE ary;
ary = rb_ary_new2(3);
rb_ary_store(ary, 0, ID2SYM(rb_intern(lang)));
rb_ary_store(ary, 1, ID2SYM(rb_intern(entity)));
rb_ary_store(ary, 2, rb_int_new(s));
rb_ary_store(ary, 3, rb_int_new(e));
rb_yield(ary);
}
}
/*
* Get the settings used for the model.
*/
static VALUE wrap_get_model_settings(VALUE self) {
if (!model_loaded)
return Qnil;
VALUE arr;
arr = rb_ary_new();
rb_ary_push(arr, rb_int_new(last_model->num_topics));
rb_ary_push(arr, rb_int_new(last_model->num_terms));
rb_ary_push(arr, rb_float_new(last_model->alpha));
return arr; // [num_topics, num_terms, alpha]
}
/**
* producer_tick
*
* This function is responsible for ticking the librdkafka reactor so we can
* get feedback from the librdkafka threads back into the Ruby environment
*
* @param self VALUE the Ruby producer instance
* @param message VALUE A Ruby FixNum of how many ms we should wait on librdkafka
*/
static VALUE producer_tick(VALUE self, VALUE timeout) {
hermann_conf_t *conf = NULL;
long timeout_ms = 0;
int events = 0;
if (Qnil != timeout) {
timeout_ms = rb_num2int(timeout);
}
else {
rb_raise(rb_eArgError, "Cannot call `tick` with a nil timeout!\n");
}
Data_Get_Struct(self, hermann_conf_t, conf);
/*
* if the producerConfig is not initialized then we never properly called
* producer_push_single, so why are we ticking?
*/
if (!conf->isInitialized) {
rb_raise(rb_eRuntimeError, "Cannot call `tick` without having ever sent a message\n");
}
events = rd_kafka_poll(conf->rk, timeout_ms);
if (conf->isErrored) {
rb_raise(rb_eStandardError, conf->error);
}
return rb_int_new(events);
}
/*
* call-seq:
* multi = Curl::Multi.new
* easy = Curl::Easy.new('url')
*
* multi.add(easy)
*
* Add an easy handle to the multi stack
*/
static VALUE ruby_curl_multi_add(VALUE self, VALUE easy) {
CURLMcode mcode;
ruby_curl_easy *rbce;
ruby_curl_multi *rbcm;
Data_Get_Struct(self, ruby_curl_multi, rbcm);
Data_Get_Struct(easy, ruby_curl_easy, rbce);
mcode = curl_multi_add_handle(rbcm->handle, rbce->curl);
if (mcode != CURLM_CALL_MULTI_PERFORM && mcode != CURLM_OK) {
raise_curl_multi_error_exception(mcode);
}
/* save a pointer to self */
rbce->self = easy;
/* setup the easy handle */
ruby_curl_easy_setup( rbce, &(rbce->bodybuf), &(rbce->headerbuf), &(rbce->curl_headers) );
rbcm->active++;
if (mcode == CURLM_CALL_MULTI_PERFORM) {
curl_multi_perform(rbcm->handle, &(rbcm->running));
}
rb_hash_aset( rbcm->requests, rb_int_new((long)rbce->curl), easy );
// active should equal INT2FIX(RHASH(rbcm->requests)->tbl->num_entries)
if (rbcm->active > rbcm->running) {
rb_curl_multi_read_info(self, rbcm->handle);
}
return self;
}
/*
* call-seq: call(in_start, in_end)
*
* Call technical function with input data from in_start..in_end.
*/
static VALUE ta_func_call(VALUE self, VALUE in_start, VALUE in_end)
{
TA_RetCode ret_code;
ParamHolder *param_holder;
TA_Integer out_start, out_num;
VALUE ary, sub_ary;
int i,j;
Data_Get_Struct(self, ParamHolder, param_holder);
ret_code = TA_CallFunc( param_holder->p, FIX2INT(in_start), FIX2INT(in_end), &out_start, &out_num);
if ( ret_code != TA_SUCCESS )
rb_raise(rb_eRuntimeError, "unsuccess return code TA_CallFunc");
ary = rb_iv_get(self, "@result");
for (i = 0; i<RARRAY_LEN(ary); i++)
if (TYPE(rb_ary_entry(ary, i)) == T_ARRAY)
{
sub_ary = rb_ary_entry(ary, i);
for (j=0; j<out_num; j++)
{
if(param_holder->out_type[i] == TA_Output_Real) {
double el = ((double*)param_holder->out[i])[j];
rb_ary_store(sub_ary, j+out_start, rb_float_new(el));
}
else if(param_holder->out_type[i] == TA_Output_Integer) {
int el = ((int*)param_holder->out[i])[j];
rb_ary_store(sub_ary, j+out_start, rb_int_new(el));
}
}
}
return rb_ary_new3(2, INT2FIX(out_start), INT2FIX(out_num));
}
/*
Convert a char *genome to ruby array of integers
*/
static VALUE genome_to_int_array(char *genome, int g_len) {
int i;
VALUE arr = rb_ary_new();
for(i=0; i < g_len; ++i) {
rb_ary_push(arr, rb_int_new((genome[i]) - '0'));
}
return arr;
}
/* initializes the Vector */
static VALUE vector_init(VALUE self, VALUE vec_vals) {
Vector *p;
register int i;
Data_Get_Struct(self, Vector, p);
/* gets the size of the ruby array that contains the new values */
if(NIL_P(vec_vals) != FALSE) {
p->size = RARRAY(vec_vals)->len;
copy_ary_to_vector(p, vec_vals); /* loads all the values in */
} else {
p->size = 3;
VALUE zero_arr = rb_ary_new();
rb_ary_push(zero_arr, rb_int_new(0));
rb_ary_push(zero_arr, rb_int_new(0));
rb_ary_push(zero_arr, rb_int_new(0));
copy_ary_to_vector(p, zero_arr);
}
return self;
}
static
VALUE rhe_read_timeout(VALUE self, VALUE fileno, VALUE rbuf, VALUE len, VALUE offset, VALUE timeout) {
char * d;
ssize_t rv;
d = malloc(len);
rv = _read_timeout(NUM2INT(fileno), NUM2DBL(timeout), &d[NUM2LONG(offset)], NUM2LONG(len));
if ( rv > 0 ) {
rb_str_cat(rbuf, d, rv);
}
free(d);
return rb_int_new(rv);
}
static
VALUE rhe_write_timeout(VALUE self, VALUE fileno, VALUE buf, VALUE len, VALUE offset, VALUE timeout) {
char* d;
ssize_t rv;
d = StringValuePtr(buf);
rv = _write_timeout(NUM2INT(fileno), NUM2DBL(timeout), &d[NUM2LONG(offset)], NUM2LONG(len));
if ( rv < 0 ) {
return Qnil;
}
return rb_int_new(rv);
}
//
// function to count the number of events for which amplitudes were generated.
//
//
VALUE count_amps(VALUE __self, VALUE __file_name){
char *filename = STR2CSTR(__file_name);
ifstream in_file;
in_file.open(filename);
int event = 0;
complex<float> amp;
while(!in_file.eof()){
event++;
in_file.read((char*)&,sizeof(amp));
}
return rb_int_new(event-1);
}
VALUE method_max_index(VALUE self, VALUE s){
int len = RSTRING_LEN(s) / 4;
int* arr = (int *) RSTRING_PTR(s);
int max = 0;
int max_idx = 0;
int i = 0;
for(i=0; i<len; i++){
if(arr[i] > max){
max = arr[i];
max_idx = i;
}
}
return rb_int_new(max_idx);
}
static void rb_curl_multi_remove(ruby_curl_multi *rbcm, VALUE easy) {
CURLMcode result;
ruby_curl_easy *rbce;
Data_Get_Struct(easy, ruby_curl_easy, rbce);
rbcm->active--;
//printf( "calling rb_curl_multi_remove: 0x%X, active: %d\n", (long)easy, rbcm->active );
result = curl_multi_remove_handle(rbcm->handle, rbce->curl);
if (result != 0) {
raise_curl_multi_error_exception(result);
}
ruby_curl_easy_cleanup( easy, rbce, rbce->bodybuf, rbce->headerbuf, rbce->curl_headers );
rbce->headerbuf = Qnil;
rbce->bodybuf = Qnil;
rb_hash_delete( rbcm->requests, rb_int_new((long)rbce->curl) );
}
static
VALUE rhe_write_all(VALUE self, VALUE fileno, VALUE buf, VALUE offsetv, VALUE timeout) {
char * d;
ssize_t buf_len;
ssize_t rv = 0;
ssize_t written = 0;
ssize_t offset = NUM2LONG(offsetv);
d = StringValuePtr(buf);
buf_len = RSTRING_LEN(buf);
written = 0;
while ( buf_len > written ) {
rv = _write_timeout(NUM2INT(fileno), NUM2DBL(timeout), &d[written], buf_len - written);
if ( rv <= 0 ) {
break;
}
written += rv;
}
if (rv < 0) {
return Qnil;
}
return rb_int_new(written);
}
VALUE call_tree_call_count(VALUE self)
{
return rb_int_new(get_call_tree(self)->call_count);
}
/*
* Get the estimate alpha value (fixed = 0).
*/
static VALUE wrap_get_estimate_alpha(VALUE self) {
return rb_int_new(ESTIMATE_ALPHA);
}
/*
* Get the number of topics being clustered.
*/
static VALUE wrap_get_num_topics(VALUE self) {
return rb_int_new(NTOPICS);
}
/*
* Get the max iterations for the EM algorithm.
*/
static VALUE wrap_get_em_max_iter(VALUE self) {
return rb_int_new(EM_MAX_ITER);
}
/* call-seq: calc_coherent_sums(cuts,ic,a,file) -> self
*
*
*
*/
VALUE calc_coherent_sums(VALUE __self, VALUE __num_files, VALUE __cuts_on,
VALUE __cuts_ary, VALUE __num_evts){
VectorFlt2D *cross_term_ints
= get_cpp_ptr(rb_iv_get(__self,"@cross_term_ints"),__VectorFlt2D__);
int cuts_on = NUM2INT(__cuts_on);
int num_amps = NUM2INT(__num_files);
int num_evts = NUM2INT(__num_evts);
double cut_check;
int good_events = 0;
ifstream in_file[num_amps];
char *amp_names[num_amps];
// array to hold the sums
complex<float> cross_terms[num_amps][num_amps];
// Naming and opening files...
for(int iter = 0;iter<num_amps;iter++){
amp_names[iter] = STR2CSTR(rb_ary_entry(rb_iv_get(__self,
"@coh_amps"),iter));
in_file[iter].open(amp_names[iter]);
}
bool take_event;
complex<float> amp[num_amps];
int event = 0;
int read_tag = 0;
while(event<num_evts && read_tag<1){
for(int j = 1;j<num_amps;j++){
if(in_file[j].eof()) read_tag++;
}
if(cuts_on){
cut_check = NUM2DBL(rb_ary_entry(__cuts_ary,event));
if(cut_check >= 0.0){
take_event = true;
}
else take_event = false;
}
else if(!cuts_on){
take_event = true;
}
// read the amp vals...
for(int amp_num = 0;amp_num<num_amps;amp_num++){
in_file[amp_num].read((char*)&[amp_num],sizeof(amp[amp_num]));
}
if(take_event){
good_events++;
for(int row = 0;row<num_amps;row++){
for(int col = row;col<num_amps;col++){
cross_terms[row][col] = cross_terms[row][col]
+ amp[row] * conj(amp[col]);
}
}
}
event++;
}
cout << "Events used: " << good_events << "\n";
// impose symmetry...
for(int row = 0;row<num_amps;row++){
for(int col = 0;col<=row;col++){
cross_terms[row][col] = conj(cross_terms[col][row]);
}
}
// assign values to VectorFlt2D...
for(int i = 0;i<num_amps;i++){
for(int j = 0;j<num_amps;j++){
(*cross_term_ints)[i][j] = cross_terms[i][j];
}
}
return rb_int_new(event);
}
/* call-seq:
line_no -> int
returns the line number of the method */
static VALUE
prof_call_info_line(VALUE self)
{
prof_call_info_t *result = prof_get_call_info_result(self);
return rb_int_new(result->line);
}
static VALUE print_size(VALUE self) {
Vector *p;
Data_Get_Struct(self, Vector, p);
return rb_int_new(p->size);
}
static
VALUE rhe_write_response(VALUE self, VALUE filenov, VALUE timeoutv, VALUE status_codev, VALUE headers, VALUE body) {
ssize_t hlen;
ssize_t blen;
ssize_t len;
ssize_t rv = 0;
ssize_t iovcnt;
ssize_t vec_offset;
ssize_t written;
int count;
int i;
char status_line[512];
char date_line[512];
int date_pushed = 0;
VALUE arr;
VALUE key_obj;
VALUE val_obj;
char * key;
int fileno = NUM2INT(filenov);
double timeout = NUM2DBL(timeoutv);
int status_code = NUM2INT(status_codev);
arr = rb_ary_new();
rb_hash_foreach(headers, my_hash_keys, arr);
hlen = RARRAY_LEN(arr);
blen = RARRAY_LEN(body);
iovcnt = 10 + (hlen * 2) + blen;
{
struct iovec v[iovcnt]; // Needs C99 compiler
/* status line */
iovcnt = 0;
i=0;
status_line[i++] = 'H';
status_line[i++] = 'T';
status_line[i++] = 'T';
status_line[i++] = 'P';
status_line[i++] = '/';
status_line[i++] = '1';
status_line[i++] = '.';
status_line[i++] = '0';
status_line[i++] = ' ';
str_i(status_line,&i,status_code,3);
status_line[i++] = ' ';
const char * message = status_message(status_code);
str_s(status_line, &i, message, strlen(message));
status_line[i++] = 13;
status_line[i++] = 10;
v[iovcnt].iov_base = status_line;
v[iovcnt].iov_len = i;
iovcnt++;
v[iovcnt].iov_base = "Connection: close\r\nServer: Rhebok\r\n";
v[iovcnt].iov_len = sizeof("Connection: close\r\nServer: Rhebok\r\n")-1;
iovcnt++;
date_pushed = 0;
for ( i = 0; i < hlen; i++ ) {
key_obj = rb_ary_entry(arr, i);
key = StringValuePtr(key_obj);
len = RSTRING_LEN(key_obj);
if ( strncasecmp(key,"Connection",len) == 0 ) {
continue;
}
if ( strncasecmp(key,"Server",len) == 0 ) {
v[1].iov_len -= (sizeof("Server: Rhebok\r\n") - 1);
}
if ( strncasecmp(key,"Date",len) == 0 ) {
date_pushed = 1;
}
v[iovcnt].iov_base = key;
v[iovcnt].iov_len = len;
iovcnt++;
v[iovcnt].iov_base = ": ";
v[iovcnt].iov_len = sizeof(": ") - 1;
iovcnt++;
/* value */
val_obj = rb_hash_aref(headers, key_obj);
v[iovcnt].iov_base = StringValuePtr(val_obj);
v[iovcnt].iov_len = RSTRING_LEN(val_obj);
iovcnt++;
v[iovcnt].iov_base = "\r\n";
v[iovcnt].iov_len = sizeof("\r\n") - 1;
iovcnt++;
}
if ( date_pushed == 0 ) {
v[iovcnt].iov_len = _date_line(date_line);
v[iovcnt].iov_base = date_line;
iovcnt++;
}
v[iovcnt].iov_base = "\r\n";
v[iovcnt].iov_len = sizeof("\r\n") - 1;
iovcnt++;
for (i=0; i < blen; i++ ) {
val_obj = rb_ary_entry(body, i);
v[iovcnt].iov_base = StringValuePtr(val_obj);
v[iovcnt].iov_len = RSTRING_LEN(val_obj);
iovcnt++;
}
vec_offset = 0;
written = 0;
while ( iovcnt - vec_offset > 0 ) {
count = (iovcnt > IOV_MAX) ? IOV_MAX : iovcnt;
rv = _writev_timeout(fileno, timeout, &v[vec_offset], count - vec_offset, (vec_offset == 0) ? 0 : 1);
if ( rv <= 0 ) {
// error or disconnected
break;
}
written += rv;
while ( rv > 0 ) {
if ( (int)rv >= v[vec_offset].iov_len ) {
rv -= v[vec_offset].iov_len;
vec_offset++;
}
else {
v[vec_offset].iov_base = (char*)v[vec_offset].iov_base + rv;
v[vec_offset].iov_len -= rv;
rv = 0;
}
}
}
}
if ( rv < 0 ) {
return Qnil;
}
return rb_int_new(written);
}
/* call-seq:
depth -> int
returns the depth of this call info in the call graph */
static VALUE
prof_call_info_depth(VALUE self)
{
prof_call_info_t *result = prof_get_call_info(self);
return rb_int_new(result->depth);
}
static
VALUE rhe_accept(VALUE self, VALUE fileno, VALUE timeoutv, VALUE tcp, VALUE env) {
struct sockaddr_in cliaddr;
unsigned int len;
char read_buf[MAX_HEADER_SIZE];
VALUE req;
int flag = 1;
ssize_t rv = 0;
ssize_t buf_len;
ssize_t reqlen;
int fd;
double timeout = NUM2DBL(timeoutv);
len = sizeof(cliaddr);
fd = _accept(NUM2INT(fileno), (struct sockaddr *)&cliaddr, len);
/* endif */
if (fd < 0) {
goto badexit;
}
rv = _read_timeout(fd, timeout, &read_buf[0], MAX_HEADER_SIZE);
if ( rv <= 0 ) {
close(fd);
goto badexit;
}
if ( IMMEDIATE_P(tcp) ) {
setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char*)&flag, sizeof(int));
rb_hash_aset(env, remote_addr_key, rb_str_new2(inet_ntoa(cliaddr.sin_addr)));
rb_hash_aset(env, remote_port_key, rb_String(rb_int_new(ntohs(cliaddr.sin_port))));
}
else {
rb_hash_aset(env, remote_addr_key, rb_str_new("",0));
rb_hash_aset(env, remote_port_key, rb_String(rb_int_new(0)));
}
buf_len = rv;
while (1) {
reqlen = _parse_http_request(&read_buf[0],buf_len,env);
if ( reqlen >= 0 ) {
break;
}
else if ( reqlen == -1 ) {
/* error */
close(fd);
goto badexit;
}
if ( MAX_HEADER_SIZE - buf_len == 0 ) {
/* too large header */
char* badreq;
badreq = BAD_REQUEST;
rv = _write_timeout(fd, timeout, badreq, sizeof(BAD_REQUEST) - 1);
close(fd);
goto badexit;
}
/* request is incomplete */
rv = _read_timeout(fd, timeout, &read_buf[buf_len], MAX_HEADER_SIZE - buf_len);
if ( rv <= 0 ) {
close(fd);
goto badexit;
}
buf_len += rv;
}
req = rb_ary_new2(3);
rb_ary_push(req, rb_int_new(fd));
rb_ary_push(req, rb_str_new(&read_buf[reqlen],buf_len - reqlen));
return req;
badexit:
return Qnil;
}
VALUE method_get_index(VALUE self, VALUE s, VALUE idx){
int* arr = (int *) RSTRING_PTR(s);
return rb_int_new(arr[NUM2INT(idx)]);
}
