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 void get_data_params(Data_Obj *dp, u_long *np, long *incp)
{
if( OBJ_COLS(dp)==1 ) { /* maybe this is a column vector? */
*np=OBJ_ROWS(dp);
*incp = OBJ_ROW_INC(dp);
} else {
*np=OBJ_COLS(dp);
*incp = OBJ_PXL_INC(dp);
}
}
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 */
int cksiz(QSP_ARG_DECL int argtyp,Data_Obj *src_dp,Data_Obj *dst_dp)
{
int i;
/* allow exception for vmaxg, etc.
* These functions return two scalars, the max value,
* and number of occurrences, PLUS a vector with the
* indices of the occurrences.
*
* But where do we check them? Do we need to do any checking for them?
*/
if( argtyp == V_SCALRET2 )
return(0);
for(i=0;i<N_DIMENSIONS;i++){
if( OBJ_TYPE_DIM(src_dp,i) != OBJ_TYPE_DIM(dst_dp,i) ){
/* special case for real/cpx fft */
if( i==1 ){
if( (argtyp & FWD_FT) && IS_REAL(src_dp) && IS_COMPLEX(dst_dp) ){
if( OBJ_COLS(dst_dp) == (1+OBJ_COLS(src_dp)/2) )
continue;
} else if( (argtyp & INV_FT) && IS_COMPLEX(src_dp) && IS_REAL(dst_dp) ){
if( OBJ_COLS(src_dp) == (1+OBJ_COLS(dst_dp)/2) )
continue;
}
}
/* if we get to here, the dimensions don't match... */
/* if the source dimension is 1, it may be an outer op */
/* if the destination dimension is 1, it may be a projection op */
if( OBJ_TYPE_DIM(src_dp,i) == 1 /* && (argtyp&VV_SOURCES) == VV_SOURCES */ ){
/* vmul, vadd, vsub, vatan2 */
/* vvm_gt etc also */
/* don't need VV_SOURCES... */
continue;
} else if( OBJ_TYPE_DIM(dst_dp,i) == 1 && CAN_PROJECT(argtyp) ){
/* vsum, vmaxv, vmainv, etc */
continue;
} else {
/* if we get to here, we're not happy... */
sprintf(ERROR_STRING,
"cksiz: %s count mismatch, %s (%d) & %s (%d)",
dimension_name[i],
OBJ_NAME(src_dp),OBJ_TYPE_DIM(src_dp,i),
OBJ_NAME(dst_dp),OBJ_TYPE_DIM(dst_dp,i));
WARN(ERROR_STRING);
return(-1);
}
}
}
return(0);
} /* end cksiz() */
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;
}
}
static int _fft_row_size_ok(QSP_ARG_DECL Data_Obj *dp, const char * funcname )
{
if( log_2(OBJ_COLS(dp)) == -1 ){
sprintf(ERROR_STRING,
"%s: number of columns of image %s (%d) is not a power of two for FFT",
funcname,OBJ_NAME(dp),OBJ_COLS(dp));
WARN(ERROR_STRING);
longlist(dp);
return(-1);
}
return(0);
}
// 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;
}
}
}
double _add_to_sos(QSP_ARG_DECL dimension_t x,dimension_t y,Data_Obj *edp,Data_Obj *fdp,int factor)
{
dimension_t i,j;
double err,adj;
incr_t xx,yy;
/*
if( the_sos == NO_VALUE )
the_sos = get_sos(edp,fdp);
*/
adj =0.0;
for(j=0;j<OBJ_ROWS(fdp);j++){
yy = (incr_t)(y + j) - (incr_t)OBJ_ROWS(fdp)/2;
#ifdef NOWRAP
if( yy >= 0 && yy < OBJ_ROWS(edp) ){
for(i=0;i<OBJ_COLS(fdp);i++){
xx = (incr_t)(x + i) - (incr_t)(OBJ_COLS(fdp)/2);
if( xx >= 0 && xx < OBJ_COLS(edp) ){
err = get_ferror(edp,fdp,xx,yy);
adj += err*err;
}
}
}
#else
while( yy < 0 ) yy += OBJ_ROWS(edp);
while( yy >= (incr_t)OBJ_ROWS(edp) ) yy -= OBJ_ROWS(edp);
for(i=0;i<OBJ_COLS(fdp);i++){
xx = x + i - OBJ_COLS(fdp)/2;
while( xx < 0 ) xx += OBJ_COLS(edp);
while( xx >= (incr_t)OBJ_COLS(edp) ) xx -= OBJ_COLS(edp);
err = get_ferror(edp,fdp,xx,yy);
adj += err*err;
}
#endif /* NOWRAP */
}
/* normalize by number of pixels */
if( factor == 1 )
adj /= (OBJ_COLS(edp) * OBJ_ROWS(edp));
else if( factor == -1 )
adj /= - (OBJ_COLS(edp) * OBJ_ROWS(edp));
#ifdef CAUTIOUS
else {
sprintf(ERROR_STRING,"CAUTIOUS: add_to_sos: factor (%d) is not 1 or -1 !?",factor);
warn(ERROR_STRING);
return(0.0);
}
#endif /* CAUTIOUS */
/* the_sos += adj; */
return(adj);
}
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);
}
}
}
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 */
}
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 dobj_iterate(Data_Obj *dp,void (*func)(Data_Obj *,index_t))
{
dimension_t comp,col,row,frm,seq;
/* offsets for sequence, frame, row, pixel, component */
dimension_t s_os, f_os, r_os, p_os, c_os;
s_os=0;
for(seq=0;seq<OBJ_SEQS(dp);seq++){
f_os = s_os;
for(frm=0;frm<OBJ_FRAMES(dp);frm++){
r_os = f_os;
for(row=0;row<OBJ_ROWS(dp);row++){
p_os = r_os;
for(col=0;col<OBJ_COLS(dp);col++){
c_os = p_os;
for(comp=0;comp<OBJ_COMPS(dp);comp++){
(*func)(dp,c_os);
c_os += OBJ_COMP_INC(dp);
}
p_os += OBJ_PXL_INC(dp);
}
r_os += OBJ_ROW_INC(dp);
}
f_os += OBJ_FRM_INC(dp);
}
s_os += OBJ_SEQ_INC(dp);
}
}
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);
}
}
void _make_dragg(QSP_ARG_DECL const char *name,Data_Obj *bm,Data_Obj *dp)
{
Draggable *dgp;
if( !dp_same_size(bm,dp,"make_dragg") ){
warn("image/bitmap size mismatch");
return;
}
if( OBJ_PREC(bm) != PREC_BIT ){
sprintf(ERROR_STRING,"Object %s has precision %s, should be %s",
OBJ_NAME(bm),PREC_NAME(OBJ_PREC_PTR(bm)),
PREC_NAME(PREC_FOR_CODE(PREC_BIT)));
warn(ERROR_STRING);
return;
}
if( OBJ_PREC(dp) != PREC_BY && OBJ_PREC(dp) != PREC_UBY ){
sprintf(ERROR_STRING,"Image %s (for draggable object) has %s precision, should be %s or %s",
OBJ_NAME(dp),PREC_NAME(OBJ_PREC_PTR(dp)),
PREC_NAME(PREC_FOR_CODE(PREC_BY)),
PREC_NAME(PREC_FOR_CODE(PREC_UBY)) );
warn(ERROR_STRING);
return;
}
dgp = new_dragg(name);
if( dgp == NULL ) return;
dgp->dg_width = (int) OBJ_COLS(dp);
dgp->dg_height = (int) OBJ_ROWS(dp);
dgp->dg_bitmap = bm;
dgp->dg_image = dp;
dgp->dg_np = mk_node(dgp);
}
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 */
}
int get_camera_names( QSP_ARG_DECL Data_Obj *str_dp )
{
// 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?
List *lp;
Node *np;
PGR_Cam *pgcp;
int i, n;
lp = pgc_list();
if( lp == NULL ){
WARN("No cameras!?");
return 0;
}
n=eltcount(lp);
if( OBJ_COLS(str_dp) < n ){
sprintf(ERROR_STRING,"String object %s has too few columns (%ld) to hold %d camera names",
OBJ_NAME(str_dp),(long)OBJ_COLS(str_dp),n);
WARN(ERROR_STRING);
n = OBJ_COLS(str_dp);
}
np=QLIST_HEAD(lp);
i=0;
while(np!=NULL){
char *dst;
pgcp = (PGR_Cam *) NODE_DATA(np);
dst = OBJ_DATA_PTR(str_dp);
dst += i * OBJ_PXL_INC(str_dp);
if( strlen(pgcp->pc_name)+1 > OBJ_COMPS(str_dp) ){
sprintf(ERROR_STRING,"String object %s has too few components (%ld) to hold camera name \"%s\"",
OBJ_NAME(str_dp),(long)OBJ_COMPS(str_dp),pgcp->pc_name);
WARN(ERROR_STRING);
} else {
strcpy(dst,pgcp->pc_name);
}
i++;
if( i>=n )
np=NULL;
else
np = NODE_NEXT(np);
}
return i;
}
static void _update_pf_viewer(QSP_ARG_DECL Platform_Viewer *pvp, Data_Obj *dp)
{
#ifdef HAVE_OPENGL
int t;
//cudaError_t e;
// unmap buffer before using w/ GL
if( BUF_IS_MAPPED(dp) ){
if( (*PF_UNMAPBUF_FN(PFDEV_PLATFORM(OBJ_PFDEV(dp))))
(QSP_ARG dp) < 0 ) {
warn("update_pf_viewer: buffer unmap error!?");
}
CLEAR_OBJ_FLAG_BITS(dp, DT_BUF_MAPPED);
// propagate change to children and parents
propagate_flag(dp,DT_BUF_MAPPED);
}
glClear(GL_COLOR_BUFFER_BIT);
glBindTexture(GL_TEXTURE_2D, OBJ_TEX_ID(dp));
// is glBindBuffer REALLY part of libGLEW???
//#ifdef HAVE_LIBGLEW
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, OBJ_BUF_ID(dp));
//#endif // HAVE_LIBGLEW
t=gl_pixel_type(dp);
glTexSubImage2D(GL_TEXTURE_2D, 0, // target, level
0, 0, // x0, y0
OBJ_COLS(dp), OBJ_ROWS(dp), // dx, dy
t,
GL_UNSIGNED_BYTE, // type
OFFSET(0)); // offset into PIXEL_UNPACK_BUFFER
//#ifdef HAVE_LIBGLEW
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
//#endif // HAVE_LIBGLEW
glBegin(GL_QUADS);
glTexCoord2f(0, 1); glVertex2f(-1.0, -1.0);
glTexCoord2f(0, 0); glVertex2f(-1.0, 1.0);
glTexCoord2f(1, 0); glVertex2f(1.0, 1.0);
glTexCoord2f(1, 1); glVertex2f(1.0, -1.0);
glEnd();
glBindTexture(GL_TEXTURE_2D, 0);
if( (*PF_MAPBUF_FN(PFDEV_PLATFORM(OBJ_PFDEV(dp))))(QSP_ARG dp) < 0 ){
warn("update_pf_viewer: Error mapping buffer!?");
}
SET_OBJ_FLAG_BITS(dp, DT_BUF_MAPPED);
// propagate change to children and parents
propagate_flag(dp,DT_BUF_MAPPED);
#else // ! HAVE_OPENGL
NO_OGL_MSG
#endif // ! HAVE_OPENGL
}
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");
}
}
static void prepare_image_for_mapping(Data_Obj *dp)
{
#ifdef HAVE_OPENGL
int t;
cudaError_t e;
// unmap buffer before using w/ GL
if( BUF_IS_MAPPED(dp) ){
e = cudaGLUnmapBufferObject( OBJ_BUF_ID(dp) );
if( e != cudaSuccess ){
describe_cuda_driver_error2("update_cuda_viewer",
"cudaGLUnmapBufferObject",e);
NERROR1("failed to unmap buffer object");
}
CLEAR_OBJ_FLAG_BITS(dp, DT_BUF_MAPPED);
// propagate change to children and parents
propagate_flag(dp,DT_BUF_MAPPED);
}
//
//bind_texture(OBJ_DATA_PTR(dp));
glClear(GL_COLOR_BUFFER_BIT);
/*
sprintf(ERROR_STRING,"update_cuda_viewer: tex_id = %d, buf_id = %d",
OBJ_TEX_ID(dp),OBJ_BUF_ID(dp));
advise(ERROR_STRING);
*/
glBindTexture(GL_TEXTURE_2D, OBJ_TEX_ID(dp));
#ifdef HAVE_LIBGLEW
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, OBJ_BUF_ID(dp));
#endif // HAVE_LIBGLEW
#ifdef FOOBAR
switch(OBJ_COMPS(dp)){
/* what used to be here??? */
}
#endif /* FOOBAR */
t=gl_pixel_type(dp);
glTexSubImage2D(GL_TEXTURE_2D, 0, // target, level
0, 0, // x0, y0
OBJ_COLS(dp), OBJ_ROWS(dp), // dx, dy
t,
GL_UNSIGNED_BYTE, // type
OFFSET(0)); // offset into PIXEL_UNPACK_BUFFER
#ifdef HAVE_LIBGLEW
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
#endif // HAVE_LIBGLEW
}
int prodimg(QSP_ARG_DECL Data_Obj *dpto,Data_Obj *rowobj,Data_Obj *colobj) /** make the product image */
{
Vec_Obj_Args oa1, *oap=&oa1;
if( OBJ_COLS(rowobj) != OBJ_COLS(dpto) ){
sprintf(DEFAULT_ERROR_STRING,
"prodimg: row size mismatch, target %s (%d) and row %s (%d)",
OBJ_NAME(dpto),OBJ_COLS(dpto),OBJ_NAME(rowobj),
OBJ_COLS(rowobj));
NWARN(DEFAULT_ERROR_STRING);
return(-1);
} else if( OBJ_ROWS(colobj) != OBJ_ROWS(dpto) ){
sprintf(DEFAULT_ERROR_STRING,
"prodimg: column size mismatch, target %s (%d) and column %s (%d)",
OBJ_NAME(dpto),OBJ_ROWS(dpto),OBJ_NAME(colobj),
OBJ_ROWS(colobj));
NWARN(DEFAULT_ERROR_STRING);
return(-1);
} else if( !same_pixel_type(QSP_ARG dpto,rowobj) ){
NWARN("type/precision mismatch");
return(-1);
} else if( !same_pixel_type(QSP_ARG dpto,colobj) ){
NWARN("type precision mismatch");
return(-1);
}
#ifdef FOOBAR
else if( ! FLOATING_OBJ(dpto) ){
NWARN("sorry, only float and double supported for prodimg");
return(-1);
} else if( IS_COMPLEX(dpto) || IS_COMPLEX(colobj)
|| IS_COMPLEX(rowobj) ){
NWARN("Sorry, complex not supported");
return(-1);
}
#endif /* FOOBAR */
setvarg3(oap,dpto,rowobj,colobj);
vmul(QSP_ARG oap);
return(0);
}
static void zero_dimension(Data_Obj *dp,float *base,int dim,long index)
{
dimension_t i;
if( dim > 1 ){
for(i=0;i<OBJ_TYPE_DIM(dp,dim);i++)
zero_dimension(dp,base+i*OBJ_TYPE_INC(dp,dim),dim-1,i);
} else {
for(i=0;i<OBJ_COLS(dp);i++)
base[i] = 0.0;
}
}
int real_fft_type(QSP_ARG_DECL Data_Obj *real_dp,Data_Obj *cpx_dp,const char *funcname)
{
// First make sure the objects match in precision and are of the correct type
if( ! real_cpx_objs_ok( real_dp, cpx_dp, funcname ) ) return -1;
if( OBJ_ROWS(real_dp) == OBJ_ROWS(cpx_dp) ){
if( ! good_xform_size( real_dp, cpx_dp, 1, funcname ) ) return -1;
if( ! dim_is_power_of_two(real_dp, 2, funcname ) ) return -1;
return 1;
} else if( OBJ_COLS(real_dp) == OBJ_COLS(cpx_dp) ){
if( ! good_xform_size( real_dp, cpx_dp, 2, funcname ) ) return -1;
if( ! dim_is_power_of_two(real_dp, 1, funcname ) ) return -1;
return 2;
} else {
sprintf(ERROR_STRING,
"%s: real data %s (%d x %d) and transform %s (%d x %d) must have one matching dimension!?",
funcname,OBJ_NAME(real_dp),OBJ_ROWS(real_dp),OBJ_COLS(real_dp),
OBJ_NAME(cpx_dp),OBJ_ROWS(cpx_dp),OBJ_COLS(cpx_dp));
WARN(ERROR_STRING);
return -1;
}
}
int get_video_mode_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_video_modes.num ){
sprintf(ERROR_STRING,"String object %s has too few columns (%ld) to hold %d modes",
OBJ_NAME(str_dp),(long)OBJ_COLS(str_dp),pgcp->pc_video_modes.num);
WARN(ERROR_STRING);
n = OBJ_COLS(str_dp);
} else {
n=pgcp->pc_video_modes.num;
}
for(i=0;i<n;i++){
int k;
const char *src;
char *dst;
k=index_of_video_mode(pgcp->pc_video_modes.modes[i]);
src = all_video_modes[k].nvm_name;
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 mode string \"%s\"",
OBJ_NAME(str_dp),(long)OBJ_COMPS(str_dp),src);
WARN(ERROR_STRING);
} else {
strcpy(dst,src);
}
}
set_script_var_from_int("n_video_modes",n);
return n;
}
static void x_play_movie(QSP_ARG_DECL Movie *mvip)
{
Data_Obj *dp;
Viewer *vp;
dp = (Data_Obj *)mvip->mvi_data;
/* longlist(dp); */
vp = vwr_of(QSP_ARG MOVIE_VIEWER_NAME);
mk_win:
if( vp == NO_VIEWER ){
vp = viewer_init(QSP_ARG MOVIE_VIEWER_NAME,OBJ_COLS(dp),OBJ_ROWS(dp),0);
if( vp == NO_VIEWER ){
WARN("couldn't create viewer");
return;
}
default_cmap(QSP_ARG VW_DPYABLE(vp) );
show_viewer(QSP_ARG vp); /* default state is to be shown */
select_viewer(QSP_ARG vp);
} else {
if( vp->vw_width != OBJ_COLS(dp) ||
vp->vw_height != OBJ_ROWS(dp) ){
sprintf(ERROR_STRING,
"Resizing movie viewer for movie %s",
OBJ_NAME(dp));
advise(ERROR_STRING);
delete_viewer(QSP_ARG vp);
vp=NO_VIEWER;
goto mk_win;
}
}
/* load_viewer got rewritten, no longer show all frames!? */
old_load_viewer(QSP_ARG vp,dp);
}
void img_clear(Data_Obj *dp)
{
dimension_t i,j;
float *ptr;
incr_t xos, yos;
ptr=(float *)OBJ_DATA_PTR(dp);
for(j=0;j<OBJ_ROWS(dp);j++){
yos = j * OBJ_ROW_INC(dp);
for(i=0;i<OBJ_COLS(dp);i++){
xos = i * OBJ_PXL_INC(dp);
*(ptr + yos + xos ) = 0.0;
}
}
}
//int _wav_to_dp(QSP_ARG_DECL Data_Obj *dp,Wav_Header *hd_p)
FIO_FT_TO_DP_FUNC(wav,Wav_Header)
{
Precision * prec_p;
dimension_t total_samples, samples_per_channel;
switch( hd_p->wh_bits_per_sample ){
case 8: prec_p=PREC_FOR_CODE(PREC_UBY); break;
case 16: prec_p=PREC_FOR_CODE(PREC_IN); break;
default:
sprintf(ERROR_STRING,
"wav_to_dp: unexpected # of bits per sample %d",
hd_p->wh_bits_per_sample);
warn(ERROR_STRING);
return(-1);
}
SET_OBJ_PREC_PTR(dp, prec_p);
SET_OBJ_COMPS(dp, hd_p->wh_n_channels );
total_samples = (dimension_t) (hd_p->wh_datasize / PREC_SIZE( prec_p ));
samples_per_channel = total_samples / OBJ_COMPS(dp);
SET_OBJ_COLS(dp, samples_per_channel);
SET_OBJ_ROWS(dp, 1);
SET_OBJ_FRAMES(dp, 1);
SET_OBJ_SEQS(dp, 1);
SET_OBJ_COMP_INC(dp, 1);
SET_OBJ_PXL_INC(dp, 1);
SET_OBJ_ROW_INC(dp, 1);
SET_OBJ_FRM_INC(dp, 1);
SET_OBJ_SEQ_INC(dp, 1);
SET_OBJ_PARENT(dp, NULL);
SET_OBJ_CHILDREN(dp, NULL);
SET_OBJ_AREA(dp, ram_area_p); /* the default */
/* dp->dt_data = hd_p->image; */ /* where do we allocate data??? */
SET_OBJ_N_TYPE_ELTS(dp, OBJ_COMPS(dp) * OBJ_COLS(dp) * OBJ_ROWS(dp)
* OBJ_FRAMES(dp) * OBJ_SEQS(dp) );
auto_shape_flags(OBJ_SHAPE(dp));
return 0;
}
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");
}
}
double get_sos(Data_Obj *edp,Data_Obj *fdp) /* get the total sq'd error */
{
incr_t i,j;
double sos, rowsos,err;
sos = 0.0;
for(j=0;j<(incr_t)OBJ_ROWS(edp);j++){
rowsos=0.0;
for(i=0;i<(incr_t)OBJ_COLS(edp);i++){
err = get_ferror(edp,fdp,i,j);
rowsos += err * err;
}
sos += rowsos;
}
/* normalize by number of pixels */
/* why rowinc and not ncols??? */
sos /= OBJ_ROWS(edp)*OBJ_ROW_INC(edp);
return(sos);
}
