static int init_matrices(SINGLE_QSP_ARG_DECL)
{
float *ptr;
int i,j;
if( c2p_dp == NULL ){
warn("init_matrices: need to specify object for c2p_mat");
return(-1);
}
if( p2c_dp == NULL ){
warn("init_matrices: need to specify object for p2c_mat");
return(-1);
}
ptr = (float *)OBJ_DATA_PTR(p2c_dp);
for(i=0;i<3;i++)
for(j=0;j<3;j++)
*ptr++ = p2c_mat[i][j];
dp_copy(c2p_dp,p2c_dp);
dt_invert(c2p_dp);
ptr = (float *)OBJ_DATA_PTR(c2p_dp);
for(i=0;i<3;i++)
for(j=0;j<3;j++)
c2p_mat[i][j] = *ptr++;
return(0);
}
static void fb_load(QSP_ARG_DECL Data_Obj *dp,int x, int y)
{
#ifdef HAVE_FB_DEV
dimension_t i,j;
/* char *p,*q; */ /* BUG probably a lot faster if we cast to long! */
long *p,*q;
u_long bytes_per_row, words_per_row;
/* BUG assume dp is the right kind of object */
if( ! IS_CONTIGUOUS(dp) ){
sprintf(ERROR_STRING,"fb_load: object %s must be contiguous",
OBJ_NAME(dp));
WARN(ERROR_STRING);
return;
}
INSURE_FB("fb_load");
p=(long *)OBJ_DATA_PTR(dp);
q=(long *)OBJ_DATA_PTR(curr_fbip->fbi_dp);
bytes_per_row = OBJ_COLS(dp) * OBJ_COMPS(dp);
words_per_row = bytes_per_row / sizeof(long);
for(i=0;i<OBJ_ROWS(dp);i++){
/* BUG we need to correct the row ptr if dp is narrower than the display */
for(j=0;j<words_per_row;j++)
*q++ = *p++;
}
#endif /* HAVE_FB_DEV */
}
void dp_jacobi(QSP_ARG_DECL Data_Obj *v_dp, Data_Obj *d_dp, Data_Obj *a_dp, int *nrotp)
{
void *a_rowlist[MAX_DIM], *v_rowlist[MAX_DIM];
int n;
if( OBJ_COLS(a_dp) != OBJ_ROWS(a_dp) ){
sprintf(DEFAULT_ERROR_STRING,"dp_jacobi: matrix %s must be square for jacobi",OBJ_NAME(a_dp));
NWARN(DEFAULT_ERROR_STRING);
return;
}
if( OBJ_COLS(v_dp) != OBJ_ROWS(v_dp) ){
sprintf(DEFAULT_ERROR_STRING,"dp_jacobi: matrix %s must be square for jacobi",OBJ_NAME(v_dp));
NWARN(DEFAULT_ERROR_STRING);
return;
}
if( OBJ_COLS(v_dp) != OBJ_COLS(a_dp) ){
sprintf(DEFAULT_ERROR_STRING,"dp_jacobi: size of eigenvector matrix %s must match input matrix %s for jacobi",
OBJ_NAME(v_dp),OBJ_NAME(a_dp));
NWARN(DEFAULT_ERROR_STRING);
return;
}
if( OBJ_COLS(d_dp) != OBJ_COLS(a_dp) ){
sprintf(DEFAULT_ERROR_STRING,"dp_jacobi: size of eigenvalue vector %s must match input matrix %s for jacobi",
OBJ_NAME(d_dp),OBJ_NAME(a_dp));
NWARN(DEFAULT_ERROR_STRING);
return;
}
if( ! IS_CONTIGUOUS(a_dp) ){
sprintf(DEFAULT_ERROR_STRING,"dp_jacobi: Object %s must be contiguous for jacobi",OBJ_NAME(a_dp));
NWARN(DEFAULT_ERROR_STRING);
return;
}
if( ! IS_CONTIGUOUS(d_dp) ){
sprintf(DEFAULT_ERROR_STRING,"dp_jacobi: Object %s must be contiguous for jacobi",OBJ_NAME(d_dp));
NWARN(DEFAULT_ERROR_STRING);
return;
}
if( ! IS_CONTIGUOUS(v_dp) ){
sprintf(DEFAULT_ERROR_STRING,"dp_jacobi: Object %s must be contiguous for jacobi",OBJ_NAME(v_dp));
NWARN(DEFAULT_ERROR_STRING);
return;
}
n = OBJ_COLS(a_dp);
/* BUG make sure types match */
if( OBJ_MACH_PREC(a_dp) == PREC_SP ){
float_init_rowlist((float **)(void *)a_rowlist,a_dp);
float_init_rowlist((float **)(void *)v_rowlist,v_dp);
float_jacobi(((float **)(void *)a_rowlist)-1,n,((float *)(OBJ_DATA_PTR(d_dp)))-1,((float **)(void *)v_rowlist)-1,nrotp);
} else if( OBJ_MACH_PREC(a_dp) == PREC_DP ){
double_init_rowlist((double **)(void *)a_rowlist,a_dp);
double_init_rowlist((double **)(void *)v_rowlist,v_dp);
double_jacobi(((double **)(void *)a_rowlist)-1,n,((double *)(OBJ_DATA_PTR(d_dp)))-1,((double **)(void *)v_rowlist)-1,nrotp);
} else {
NWARN("bad precision in dp_jacobi");
}
}
void dp_moment(QSP_ARG_DECL Data_Obj *d_dp)
{
/* std_type *d_rowlist[MAX_DIM]; */
int n;
if( ! IS_CONTIGUOUS(d_dp) ){
sprintf(DEFAULT_ERROR_STRING,"dp_moment: Object %s must be contiguous for eigsrt",OBJ_NAME(d_dp));
NWARN(DEFAULT_ERROR_STRING);
return;
}
n = OBJ_COLS(d_dp);
if( OBJ_MACH_PREC(d_dp) == PREC_SP ){
float adev, var, skew, curt;
float ave, sdev;
/* BUG - the results don't get passed out anywhere!?
*/
float_moment(((float *)(OBJ_DATA_PTR(d_dp))),n,&ave,&adev,&sdev,&var,&skew,&curt);
} else if( OBJ_MACH_PREC(d_dp) == PREC_DP ){
double adev, var, skew, curt;
double ave, sdev;
double_moment(((double *)(OBJ_DATA_PTR(d_dp))),n,&ave,&adev,&sdev,&var,&skew,&curt);
}
}
static void fb_save(QSP_ARG_DECL Data_Obj *dp,int x, int y)
{
#ifdef HAVE_FB_DEV
dimension_t i,j,k;
char *p,*q;
/* BUG assume dp is the right kind of object */
if( ! IS_CONTIGUOUS(dp) ){
sprintf(ERROR_STRING,"fb_save: object %s must be contiguous",
OBJ_NAME(dp));
WARN(ERROR_STRING);
return;
}
INSURE_FB("fb_save");
p=(char *)OBJ_DATA_PTR(dp);
q=(char *)OBJ_DATA_PTR(curr_fbip->fbi_dp);
/* BUG this byte-at-a-time copy is horribly inefficient */
for(i=0;i<OBJ_ROWS(dp);i++)
for(j=0;j<OBJ_COLS(dp);j++)
for(k=0;k<OBJ_COMPS(dp);k++)
*p++ = *q++;
#endif /* HAVE_FB_DEV */
}
static float get_start_val(Data_Obj *source,Data_Obj *control,dimension_t index)
{
float *f,*c,sum;
int i=0;
f = (float *)OBJ_DATA_PTR(source);
f += index*OBJ_PXL_INC(source);
c = (float *)OBJ_DATA_PTR(control);
c += index*OBJ_PXL_INC(control);
sum = 0.0;
while( (((int)index)-i) >= 0 && *c == 1.0 && i < max_avg ){
sum += *f;
f -= OBJ_PXL_INC(source);
c -= OBJ_PXL_INC(control);
i++;
}
#ifdef DEBUG
if( debug ){
sprintf(DEFAULT_ERROR_STRING,"get_start_val: index = %d n = %d sum = %f",index,i,sum);
NADVISE(DEFAULT_ERROR_STRING);
}
#endif
sum /= i;
return(sum);
}
static int _ocl_obj_alloc(QSP_ARG_DECL Data_Obj *dp, dimension_t size, int align )
{
OBJ_DATA_PTR(dp) = ocl_mem_alloc(OBJ_PFDEV(dp), size, align );
if( OBJ_DATA_PTR(dp) == NULL ){
sprintf(ERROR_STRING,"ocl_obj_alloc: error allocating memory for object %s!?",OBJ_NAME(dp));
warn(ERROR_STRING);
return -1;
}
return 0;
}
void convert_polh_vector(Data_Obj *flt_dp,Data_Obj *polh_dp)
{
uint32_t i,j;
short *rpdp;
float *cvt_p;
Fmt_Pt fp1;
int station;
if( OBJ_PREC(flt_dp) != PREC_SP ){
sprintf(ERROR_STRING,"convert_polh_data: object %s has precision %s, should be %s",
OBJ_NAME(flt_dp),PREC_NAME(OBJ_PREC_PTR(flt_dp)),PREC_NAME(prec_for_code(PREC_SP)));
warn(ERROR_STRING);
return;
}
if( OBJ_COLS(flt_dp) != OBJ_COLS(polh_dp) ){
sprintf(ERROR_STRING,"convert_polh_data: vectors %s (%d) and %s (%d) do not have the same number of columns",
OBJ_NAME(flt_dp),OBJ_COLS(flt_dp),OBJ_NAME(polh_dp),OBJ_COLS(polh_dp));
warn(ERROR_STRING);
return;
}
/* BUG should make sure that tdim of flt_dp is correct! */
/* assume that the object has already been checked for proper dim, type... */
if( n_active_stations == 2 )
station=0;
else if(n_active_stations < 1 ){
warn("format_polh_vector: no active stations!?");
return;
} else
station=curr_station_idx;
rpdp = (short *) OBJ_DATA_PTR(polh_dp);
for(i=0;i<OBJ_COLS(polh_dp);i++){
Polh_Record_Format *prfp;
cvt_p = ((float *) OBJ_DATA_PTR(flt_dp)) + i * OBJ_PXL_INC(flt_dp);
prfp = &station_info[station].sd_multi_prf;
format_polh_data(&fp1,rpdp,prfp);
for(j=0;j<prfp->rf_n_data;j++){
Polh_Output_Type type;
type = prfp->rf_output[j];
convert_chunk(cvt_p,&fp1,type);
cvt_p += od_tbl[type].od_strings; /* BUG not the right variable?... */
}
rpdp += prfp->rf_n_words;
if( n_active_stations == 2 )
station ^= 1;
}
}
void dp_zroots(Data_Obj *r_dp, Data_Obj *a_dp, int polish )
{
int m,n;
n=OBJ_COLS(a_dp); /* polynomial degree + 1 */
m=OBJ_COLS(r_dp);
if( m != n-1 ){
sprintf(DEFAULT_ERROR_STRING,
"dp_zroots: len of root vector %s (%d) inconsistent with coefficients vector %s (%d)",
OBJ_NAME(r_dp),OBJ_COLS(r_dp),OBJ_NAME(a_dp),OBJ_COLS(a_dp));
NWARN(DEFAULT_ERROR_STRING);
return;
}
/* BUG make sure are row vectors */
if(OBJ_ROWS(a_dp) != 1 ){
sprintf(DEFAULT_ERROR_STRING,"dp_zroots: coefficient vector %s should be a row vector, (rows = %d)!?",
OBJ_NAME(a_dp),OBJ_ROWS(a_dp));
NWARN(DEFAULT_ERROR_STRING);
return;
}
if( OBJ_ROWS(r_dp) != 1 ){
sprintf(DEFAULT_ERROR_STRING,"dp_zroots: root vector %s should be a row vector, (rows = %d)!?",
OBJ_NAME(r_dp),OBJ_ROWS(r_dp));
NWARN(DEFAULT_ERROR_STRING);
return;
}
/* BUG make sure all vectors have same precision */
if( OBJ_MACH_PREC(a_dp) == PREC_SP ){
/* Why do we subtract 1 from the address of the roots, but not
* the coefficients!?
*/
float_zroots(
((fcomplex *)OBJ_DATA_PTR(a_dp))/*-1*/,
m,
((fcomplex *)OBJ_DATA_PTR(r_dp))-1,
polish);
} else if( OBJ_MACH_PREC(a_dp) == PREC_DP ){
double_zroots( ((dcomplex *)OBJ_DATA_PTR(a_dp))-1,m,((dcomplex *)OBJ_DATA_PTR(r_dp))-1,polish);
}
else {
NWARN("bad machine precision in dp_zroots");
}
}
void format_polh_vector(Data_Obj *dp)
{
uint32_t i;
short *rpdp;
Fmt_Pt fp1;
int station;
/* assume that the object has already been checked for proper dim, type... */
if( n_active_stations == 2 )
station=0;
else if(n_active_stations < 1 ){
warn("format_polh_vector: no active stations!?");
return;
} else
station=curr_station_idx;
rpdp = (short *) OBJ_DATA_PTR(dp);
for(i=0;i<OBJ_COLS(dp);i++){
Polh_Record_Format *prfp;
prfp = &station_info[station].sd_multi_prf;
format_polh_data(&fp1,rpdp,prfp);
display_formatted_point(QSP_ARG &fp1,prfp);
rpdp += prfp->rf_n_words;
if( n_active_stations == 2 )
station ^= 1;
}
}
void _convolve(QSP_ARG_DECL Data_Obj *dpto,Data_Obj *dpfr,Data_Obj *dpfilt)
{
dimension_t i,j;
float val, *frptr;
dimension_t yos, offset;
// where is the other error checking done???
INSIST_RAM_OBJ(dpto,convolve)
INSIST_RAM_OBJ(dpfr,convolve)
INSIST_RAM_OBJ(dpfilt,convolve)
img_clear(dpto);
frptr = (float *) OBJ_DATA_PTR(dpfr);
j=OBJ_ROWS(dpto);
while(j--){
yos = j * OBJ_ROW_INC(dpfr);
i=OBJ_COLS(dpfr);
while(i--){
offset = yos+i*OBJ_PXL_INC(dpfr);
val = *(frptr+offset);
add_impulse(val,dpto,dpfilt,i,j);
}
}
}
int get_framerate_strings( QSP_ARG_DECL Data_Obj *str_dp, PGR_Cam *pgcp )
{
// Could check format of object here...
// Should be string table with enough entries to hold the modes
// Should the strings be rows or multidim pixels?
int i, n;
if( OBJ_COLS(str_dp) < pgcp->pc_framerates.num ){
sprintf(ERROR_STRING,"String object %s has too few columns (%ld) to hold %d framerates",
OBJ_NAME(str_dp),(long)OBJ_COLS(str_dp),pgcp->pc_framerates.num);
WARN(ERROR_STRING);
n = OBJ_COLS(str_dp);
} else {
n=pgcp->pc_framerates.num;
}
for(i=0;i<n;i++){
const char *src;
char *dst;
src = name_for_framerate(pgcp->pc_framerates.framerates[i]);
dst = OBJ_DATA_PTR(str_dp);
dst += i * OBJ_PXL_INC(str_dp);
if( strlen(src)+1 > OBJ_COMPS(str_dp) ){
sprintf(ERROR_STRING,"String object %s has too few components (%ld) to hold framerate string \"%s\"",
OBJ_NAME(str_dp),(long)OBJ_COMPS(str_dp),src);
WARN(ERROR_STRING);
} else {
strcpy(dst,src);
}
}
return n;
}
static Data_Obj *make_1394frame_obj(QSP_ARG_DECL dc1394video_frame_t *framep)
{
Dimension_Set dimset;
Data_Obj *dp;
char fname[32];
sprintf(fname,"_frame%d",framep->id);
dimset.ds_dimension[0] = 1; /* 1 or two depending on video mode (8 or 16) */
dimset.ds_dimension[1] = framep->size[0];
dimset.ds_dimension[2] = framep->size[1];
dimset.ds_dimension[3] = 1;
dimset.ds_dimension[4] = 1;
dp = _make_dp(QSP_ARG fname,&dimset,PREC_FOR_CODE(PREC_UBY));
/* Do we need to test for a good return value??? */
/* Only one buffer? where do we specify the index? BUG */
SET_OBJ_DATA_PTR(dp, framep->image);
if( verbose )
fprintf(stderr,"Object %s, data ptr set to 0x%lx\n",OBJ_NAME(dp),(long)OBJ_DATA_PTR(dp));
if( framep->total_bytes != framep->image_bytes ){
sprintf(DEFAULT_ERROR_STRING,"image may be padded...");
warn(DEFAULT_ERROR_STRING);
}
return(dp);
}
static void _ocl_obj_free(QSP_ARG_DECL Data_Obj *dp)
{
cl_int ret;
ret = clReleaseMemObject( (cl_mem) OBJ_DATA_PTR(dp) ); //free memory on device
// BUG check return value
}
static void float_sort_svd_eigenvectors(Data_Obj *u_dp, Data_Obj *w_dp, Data_Obj *v_dp)
{
//SORT_EIGENVECTORS(float)
dimension_t i,n;
u_long *index_data;
n = OBJ_COLS(w_dp);
index_dp = mkvec("svd_tmp_indices",n,1,PREC_UDI);
if( index_dp == NULL ){
NWARN("Unable to create index object for sorting SVD eigenvalues");
return;
}
sort_indices(index_dp,w_dp);
/* sorting is done from smallest to largest */
j=0;
index_data = OBJ_DATA_PTR(index_dp);
/* We should only have to have 1 column of storage to permute things,
* but life is simplified if we copy the data...
*/
for(i=n-1;i>=0;i--){
k= *(index_data+i);
}
}
void gpu_obj_dnload(QSP_ARG_DECL Data_Obj *dpto,Data_Obj *dpfr)
{
size_t siz;
CHECK_RAM("gpu_obj_dnload","destination",dpto)
CHECK_NOT_RAM("gpu_obj_dnload","source",dpfr)
CHECK_CONTIG_DATA("gpu_obj_dnload","source",dpfr)
CHECK_CONTIG_DATA("gpu_obj_dnload","destination",dpto)
CHECK_SAME_SIZE(dpto,dpfr,"gpu_obj_dnload")
CHECK_SAME_PREC(dpto,dpfr,"gpu_obj_dnload")
/* TEST - does this work for bitmaps? */
siz = OBJ_N_MACH_ELTS(dpto) * PREC_SIZE( OBJ_PREC_PTR(dpto) );
gpu_mem_dnload(QSP_ARG OBJ_DATA_PTR(dpto), OBJ_DATA_PTR(dpfr), siz );
}
void read_polh_vector(QSP_ARG_DECL Data_Obj *dp)
{
void *raw_pdp;
int records_to_read;
int station;
static Polh_Read_Info pri1;
if( polh_continuous ){
WARN("start_async_read: polhemus is already in continuous mode!?");
} else {
//advise("read_polh_vector: starting continuous mode");
start_continuous_mode();
//WARN("read_polh_vector: exiting before reading for debugging purposes!");
//return;
}
if( ! good_polh_vector(QSP_ARG dp) ) return;
raw_pdp = OBJ_DATA_PTR(dp);
records_to_read = OBJ_N_MACH_ELTS(dp) / station_info[ curr_station_idx ].sd_multi_prf.rf_n_words;
//fprintf(stderr,"Will attempt to read %d records...\n",records_to_read);
/* BUG station login assumes max 2 stations as in insidetrak... */
if( n_active_stations == 2 ){
station=0;
} else if( n_active_stations == 1 )
station = curr_station_idx;
else {
sprintf(ERROR_STRING,"read_polh_vector: number of active stations (%d) should be 1 or 2",
n_active_stations);
WARN(ERROR_STRING);
return;
}
#ifdef THREAD_SAFE_QUERY
pri1.pri_qsp = THIS_QSP;
#endif // THREAD_SAFE_QUERY
pri1.pri_n_requested = records_to_read;
pri1.pri_n_obtained = 0;
pri1.pri_addr = raw_pdp;
pri1.pri_station = station;
halting=0;
//sprintf(ERROR_STRING,"read_polh_vector: _read_async = %d",_read_async);
//advise(ERROR_STRING);
if( _read_async ){
advise("read_polh_vector: calling start_data_thread");
start_data_thread(&pri1);
} else {
advise("read_polh_vector: calling transfer_polh_data");
transfer_polh_data(&pri1);
}
}
static void cu2_mem_free(QSP_ARG_DECL Data_Obj *dp)
{
cudaError_t e;
// GLOBAL
e = cudaFree(OBJ_DATA_PTR(dp));
if( e != cudaSuccess ){
describe_cuda_driver_error2("release_data","cudaFree",e);
}
}
void double_init_rowlist(double **list, Data_Obj *dp)
{
unsigned i;
double *fbase;
fbase = ((double *)OBJ_DATA_PTR(dp));
fbase --; /* for numrec fortran indices */
for(i=0;i<OBJ_ROWS(dp);i++)
*list++ = fbase + i*OBJ_ROW_INC(dp); /* ??? *dp->dt_pinc; */
}
void dp_choldc(Data_Obj *a_dp, Data_Obj *p_dp)
{
unsigned m, n;
void *a_rowlist[MAX_DIM];
/*
n=OBJ_ROWS(a_dp);
if( n > MAX_DIM ){
NWARN("Sorry, MAX dimension exceeded in dp_choldc");
sprintf(DEFAULT_ERROR_STRING,"dp_choldc: MAX_DIM = %d, n = %d", MAX_DIM,n);
NADVISE(DEFAULT_ERROR_STRING);
return;
}
*/
n=OBJ_COLS(a_dp);
m=OBJ_ROWS(a_dp);
if( n > MAX_DIM || m > MAX_DIM ){
NWARN("Sorry, MAX dimension exceeded in dp_choldc");
sprintf(DEFAULT_ERROR_STRING,"dp_choldc: MAX_DIM = %d, n = %d, m = %d",
MAX_DIM,n,m);
NADVISE(DEFAULT_ERROR_STRING);
return;
}
printf("nrmenu:numrec.c data %f\n", *((float *)OBJ_DATA_PTR(a_dp)));
if( OBJ_MACH_PREC(a_dp) == PREC_SP ){
float_init_rowlist((float **)(void *)a_rowlist,a_dp);
float_choldc(((float **)(void *)a_rowlist)-1,n,((float *)OBJ_DATA_PTR(p_dp))-1);
} else if( OBJ_MACH_PREC(a_dp) == PREC_DP ){
double_init_rowlist((double **)(void *)a_rowlist,a_dp);
double_choldc(((double **)(void *)a_rowlist)-1,n,((double *)OBJ_DATA_PTR(p_dp))-1);
}
else {
NWARN("bad machine precision in dp_choldc");
}
}
static COMMAND_FUNC( do_sv_mv_mat )
{
Data_Obj *dp;
const char *matrix = NAMEOF("matrix type");
dp=pick_obj("matrix object");
if( dp == NULL ) return;
/* BUG check size & type here */
if((strcmp(matrix,"modelview"))&&(strcmp(matrix,"projection"))){
advise("Valid types of matrices are: 'modelview' 'projection'");
return;
}
if (!(strcmp(matrix, "modelview")))
glGetFloatv(GL_MODELVIEW_MATRIX,(GLfloat *)OBJ_DATA_PTR(dp));
if (!(strcmp(matrix, "projection")))
glGetFloatv(GL_PROJECTION_MATRIX,(GLfloat *)OBJ_DATA_PTR(dp));
}
static float get_end_val(Data_Obj *source,Data_Obj *control,dimension_t index)
{
float *f,*c,sum;
int i=0;
f = (float *)OBJ_DATA_PTR(source);
f += index*OBJ_PXL_INC(source);
c = (float *)OBJ_DATA_PTR(control);
c += index*OBJ_PXL_INC(control);
sum = 0.0;
while( (index+i) < OBJ_COLS(source) && *c == 1.0 && i < max_avg ){
sum += *f;
f += OBJ_PXL_INC(source);
c += OBJ_PXL_INC(control);
i++;
}
sum /= i;
return(sum);
}
void add_impulse(double amp,Data_Obj *image_dp,Data_Obj *ir_dp,posn_t x,posn_t y)
{
float *image_ptr, *irptr;
incr_t i,j;
incr_t yos,xos,offset; /* offsets into image */
incr_t iryos,iros; /* offsets into impulse response */
incr_t pinc, ir_pinc;
pinc = OBJ_PXL_INC(image_dp);
ir_pinc = OBJ_PXL_INC(ir_dp);
image_ptr = (float *) OBJ_DATA_PTR(image_dp);
irptr = (float *) OBJ_DATA_PTR(ir_dp);
j=OBJ_ROWS(ir_dp);
while( j-- ){ /* foreach impulse row */
yos = ((y+j)-OBJ_ROWS(ir_dp)/2);
#ifdef NOWRAP
if( yos < 0 || yos >= (incr_t) OBJ_ROWS(image_dp) ) continue;
#else
if( yos < 0 ) yos+=OBJ_ROWS(image_dp);
else if( yos >= OBJ_ROWS(image_dp) ) yos-=OBJ_ROWS(image_dp);
#endif /* NOWRAP */
yos *= OBJ_ROW_INC(image_dp);
iryos = j * OBJ_ROW_INC(ir_dp);
i=OBJ_COLS(ir_dp);
while(i--){
xos = ((x+i)-OBJ_COLS(ir_dp)/2);
#ifdef NOWRAP
if( xos < 0 || xos >= (incr_t) OBJ_COLS(image_dp) ) continue;
#else
if( xos < 0 ) xos+=OBJ_COLS(image_dp);
else if( xos >= OBJ_COLS(image_dp) ) xos-=OBJ_COLS(image_dp);
#endif /* NOWRAP */
offset = (yos + xos*pinc);
iros = (iryos + i*ir_pinc);
*(image_ptr+offset) += *(irptr+iros) * amp;
}
}
}
void gpu_obj_upload(QSP_ARG_DECL Data_Obj *dpto, Data_Obj *dpfr)
{
size_t siz;
CHECK_NOT_RAM("do_gpu_obj_upload","destination",dpto)
CHECK_RAM("do_gpu_obj_upload","source",dpfr)
CHECK_CONTIG_DATA("do_gpu_obj_upload","source",dpfr)
CHECK_CONTIG_DATA("do_gpu_obj_upload","destination",dpto)
CHECK_SAME_SIZE(dpto,dpfr,"do_gpu_obj_upload")
CHECK_SAME_PREC(dpto,dpfr,"do_gpu_obj_upload")
#ifdef FOOBAR
if( IS_BITMAP(dpto) )
siz = BITMAP_WORD_COUNT(dpto) * PREC_SIZE( PREC_FOR_CODE(BITMAP_MACH_PREC) );
else
siz = OBJ_N_MACH_ELTS(dpto) * PREC_SIZE( OBJ_MACH_PREC_PTR(dpto) );
#endif /* FOOBAR */
siz = OBJ_N_MACH_ELTS(dpto) * PREC_SIZE( OBJ_MACH_PREC_PTR(dpto) );
gpu_mem_upload(QSP_ARG OBJ_DATA_PTR(dpto), OBJ_DATA_PTR(dpfr), siz );
}
static COMMAND_FUNC( do_mul_mat )
{
Data_Obj *dp;
dp=pick_obj("matrix object");
if( dp == NULL ) return;
/* BUG check size & type here */
if( debug & gl_debug ) advise("glMultMatrixf");
glMultMatrixf((GLfloat *)OBJ_DATA_PTR(dp));
}
int cu2_map_buf(QSP_ARG_DECL Data_Obj *dp)
{
cudaError_t e;
e = cudaGLMapBufferObject( &OBJ_DATA_PTR(dp), OBJ_BUF_ID(dp) );
if( e != cudaSuccess ){
describe_cuda_driver_error2("cu2_map_buf",
"cudaGLMapBufferObject",e);
return -1;
}
return 0;
}
void assign_polh_var_data(char *varname, Data_Obj *dp, Polh_Output_Type type, int index )
{
short *rpdp;
Fmt_Pt fp1;
Polh_Record_Format *prfp;
char str[64];
char *s,*s2;
int i;
if( OBJ_COLS(dp) != 1 ){
sprintf(ERROR_STRING,"assign_polh_var_data: object %s has %d columns, should be 1",
OBJ_NAME(dp),OBJ_COLS(dp));
warn(ERROR_STRING);
return;
}
rpdp = (short *) OBJ_DATA_PTR(dp);
prfp = &station_info[curr_station_idx].sd_multi_prf;
format_polh_data(&fp1,rpdp,prfp);
separator=""; /* no leading tab before the first record */
if( fmt_one(msg_str,&fp1,type) < 0 )
return;
s=msg_str;
i=index;
while(i--){
while( *s!=0 && !isspace(*s) ) s++; /* skip data */
while( *s!=0 && isspace(*s) ) s++; /* skip spaces */
}
#ifdef CAUTIOUS
if( *s == 0 ){
sprintf(ERROR_STRING,"CAUTIOUS: assign_polh_var_data: not enough words for index %d",
index);
warn(ERROR_STRING);
sprintf(ERROR_STRING,"formatted string: %s",msg_str);
advise(ERROR_STRING);
return;
}
#endif /* CAUTIOUS */
/* we have to do this check in case index is zero, so the check for leading spaces hasn't been
* performed above. This is an issue with milliseconds, where a leading space may appear
* in the string for values less than 100.
*/
while( *s!=0 && isspace(*s) ) s++; /* skip any leading spaces */
s2 = str;
while( *s != 0 && !isspace(*s) )
*s2++ = *s++;
*s2=0; /* BUG should check for overflow */
assign_var(varname,str);
} /* end assign_polh_var_data */
VALUE make_hash(size_t start_buckets) {
VALUE ret;
HASH_OBJECT *hash;
hash = NGS_MALLOC(sizeof(*hash));
assert(hash);
SET_OBJ(ret, hash);
OBJ_TYPE_NUM(ret) = T_HASH;
if(start_buckets) {
OBJ_DATA_PTR(ret) = NGS_MALLOC(start_buckets * sizeof(HASH_OBJECT_ENTRY *));
memset(OBJ_DATA_PTR(ret), 0, start_buckets * sizeof(HASH_OBJECT_ENTRY *)); // XXX check if needed
} else {
OBJ_DATA_PTR(ret) = NULL;
}
HASH_BUCKETS_N(ret) = start_buckets;
HASH_HEAD(ret) = NULL;
HASH_TAIL(ret) = NULL;
OBJ_LEN(ret) = 0;
return ret;
}
// BUG this assumes contiguity
void unity(Data_Obj *mp) /**/
{
dimension_t i,j;
float *f;
f=(float *)OBJ_DATA_PTR(mp);
for(i=0;i<OBJ_COLS(mp);i++){
for(j=0;j<OBJ_COLS(mp);j++){
if(i==j) *f++ = 1.0;
else *f++ = 0.0;
}
}
}
static int parse_polh_reading( QSP_ARG_DECL Data_Obj *dp, char * s )
{
char str[32];
float *f_p;
#ifdef QUIP_DEBUG
if( debug & debug_polhemus ){
sprintf(ERROR_STRING,"parse_polh_reading \"%s\"",show_printable(DEFAULT_QSP_ARG s));
advise(ERROR_STRING);
}
#endif /* QUIP_DEBUG */
if( OBJ_PREC(dp) != PREC_SP ){
sprintf(ERROR_STRING,"Object %s has %s precision, should be %s",
OBJ_NAME(dp),
PREC_NAME(OBJ_PREC_PTR(dp)),
PREC_NAME(prec_for_code(PREC_SP)) );
warn(ERROR_STRING);
return(-1);
}
if( ! IS_CONTIGUOUS(dp) ){
sprintf(ERROR_STRING,"Object %s should be contiguous",OBJ_NAME(dp));
warn(ERROR_STRING);
return(-1);
}
if( OBJ_N_MACH_ELTS(dp) < 6 ){
sprintf(ERROR_STRING,"Object %s should have at least 6 elements",OBJ_NAME(dp));
warn(ERROR_STRING);
return(-1);
}
f_p = OBJ_DATA_PTR(dp);
if( sscanf(s,"%s %f %f %f %f %f %f",str,
f_p+0,
f_p+1,
f_p+2,
f_p+3,
f_p+4,
f_p+5
) != 7 ){
sprintf(ERROR_STRING,"Error scanning polhemus data string");
warn(ERROR_STRING);
sprintf(ERROR_STRING,"String: \"%s\"",show_printable(DEFAULT_QSP_ARG s));
advise(ERROR_STRING);
return(-1);
}
return(0);
}
