Task::Task(Project* project, const std::string taskDef) { qDebug("Task::Task(Project* project, std::string* taskDef)"); _project = project; _totalTime = 0; _logs = new vector<TaskLog*>(); hashmap* values = parseTextFormat(taskDef); _id = new std::string(READ_ELEMENT(values, "task-id")); qDebug("Loading task id: %s", _id->c_str()); _shortDescription = new std::string(READ_ELEMENT(values, "short-description")); _longDescription = new std::string(READ_ELEMENT(values, "long-description")); _duration = Duration(READ_ELEMENT(values, "duration").c_str()); _startDate = new DateTime(READ_ELEMENT(values, "startdate")); _endDate = new DateTime(READ_ELEMENT(values, "enddate")); _templateName = new string(READ_ELEMENT(values, "template-name")); _status = new string(READ_ELEMENT(values, "status")); Template* tpl = readTemplate(*_templateName); // Check the current template existance if (tpl == NULL) { qDebug("Warning: The task with id: %s contains an invalid template: %s", _id->c_str(), _templateName->c_str()); _templateName = defaultTemplate()->name(); _status = new string(*defaultTemplate()->statusList().begin()); } int red = randColor(); int green = randColor(); int blue = randColor(); _taskColor = QColor(red, green, blue); _parentTask = NULL; delete(values); qDebug("out Task::Task(Project* project, std::string* taskDef)"); }
/*{{{ recode(transform_info_ptr tinfo) {*/ METHODDEF DATATYPE * recode(transform_info_ptr tinfo) { struct recode_storage *local_arg=(struct recode_storage *)tinfo->methods->local_storage; transform_info_ptr const tinfoptr=tinfo; array myarray; int itempart; int shift, nrofshifts=1; DATATYPE *save_tsdata; tinfo_array(tinfoptr, &myarray); /* The channels are the vectors */ save_tsdata=myarray.start; if (tinfoptr->data_type==FREQ_DATA) { nrofshifts=tinfoptr->nrofshifts; } for (shift=0; shift<nrofshifts; shift++) { myarray.start=save_tsdata+shift*tinfo->nroffreq*tinfo->nr_of_channels*tinfo->itemsize; array_setreadwrite(&myarray); for (itempart=local_arg->fromitem; itempart<=local_arg->toitem; itempart++) { array_use_item(&myarray, itempart); do { if (local_arg->have_channel_list && !is_in_channellist(myarray.current_vector+1, local_arg->channel_list)) { array_nextvector(&myarray); continue; } do { DATATYPE hold=READ_ELEMENT(&myarray); struct blockdef *inblocks=local_arg->blockdefs; while (inblocks!=NULL) { if (isnan(inblocks->fromstart) && isnan(hold)) { /* Recode NaN values */ hold=inblocks->tostart; } else if (hold>=inblocks->fromstart && hold<=inblocks->fromend) { if (inblocks->fromend==inblocks->fromstart || inblocks->toend==inblocks->tostart) { hold=inblocks->tostart; } else { hold=((hold-inblocks->fromstart)/(inblocks->fromend-inblocks->fromstart))*(inblocks->toend-inblocks->tostart)+inblocks->tostart; } break; } if (inblocks->last_block) break; inblocks++; } array_write(&myarray, hold); } while (myarray.message==ARRAY_CONTINUE); } while (myarray.message==ARRAY_ENDOFVECTOR); } } return tinfo->tsdata; }
/*{{{ export_point(transform_info_ptr tinfo) {*/ METHODDEF DATATYPE * export_point(transform_info_ptr tinfo) { struct export_point_info *exp_info=(struct export_point_info *)tinfo->methods->local_storage; transform_argument *args=tinfo->methods->arguments; array_dump_format format=(args[ARGS_MATLAB].is_set ? ARRAY_MATLAB : ARRAY_ASCII); int channel, itempart, i; double *channelpos; array myarray, newarray; if (exp_info->pointno<0 || exp_info->pointno>=tinfo->nr_of_points) { ERREXIT1(tinfo->emethods, "export_point: Point number %d is out of range.\n", MSGPARM(exp_info->pointno)); } TRACEMS2(tinfo->emethods, 1, "export_point: Exporting point number %d to file %s\n", MSGPARM(exp_info->pointno), MSGPARM(args[ARGS_OFILE].arg.s)); if (args[ARGS_CLOSE].is_set) export_file_open(tinfo); tinfo_array(tinfo, &myarray); myarray.current_element=exp_info->pointno; if (exp_info->channelcoords_to_display==0 && tinfo->itemsize==1) { /*{{{ Don't need to build new array, just access tinfo*/ newarray=myarray; array_transpose(&newarray); array_setto_vector(&newarray); /* Select only one element */ array_transpose(&newarray); /*}}} */ } else { /*{{{ Build new array containing the data*/ newarray.nr_of_vectors=myarray.nr_of_vectors; newarray.nr_of_elements=exp_info->channelcoords_to_display+tinfo->itemsize; newarray.element_skip=1; if (array_allocate(&newarray)==NULL) { ERREXIT(tinfo->emethods, "export_point: Can't allocate output array\n"); } for (channel=0; channel<tinfo->nr_of_channels; channel++) { channelpos=tinfo->probepos+3*channel; for (i=0; i<exp_info->channelcoords_to_display; i++) { array_write(&newarray, channelpos[i]); } myarray.current_vector=channel; for (itempart=0; itempart<tinfo->itemsize; itempart++) { array_use_item(&myarray, itempart); array_write(&newarray, READ_ELEMENT(&myarray)); } } /*}}} */ } array_dump(exp_info->file, &newarray, format); if (newarray.nr_of_elements>1) array_free(&newarray); if (args[ARGS_CLOSE].is_set) export_file_close(tinfo); return tinfo->tsdata; }
char* readValue(std::string cont, std::string key) { hashmap* map = parseTextFormat(cont); std::string value = READ_ELEMENT(map, key); char* res = NULL; if (value.size() == 0) { res = strcpy(""); } else { res = strcpy(value); } delete(map); return res; }
/*{{{ rereference(transform_info_ptr tinfo)*/ METHODDEF DATATYPE * rereference(transform_info_ptr tinfo) { struct rereference_args_struct *rereference_args=(struct rereference_args_struct *)tinfo->methods->local_storage; transform_argument *args=tinfo->methods->arguments; int itempart; transform_info_ptr const tinfoptr=tinfo; array indata; tinfo_array(tinfoptr, &indata); array_transpose(&indata); /* Vector=map */ for (itempart=0; itempart<tinfoptr->itemsize-tinfoptr->leaveright; itempart++) { array_use_item(&indata, itempart); do { DATATYPE mean=0; int n=0; do { if (is_in_channellist(indata.current_element+1, rereference_args->refchannel_numbers)) { mean+=array_scan(&indata); n++; } else { array_advance(&indata); } } while (indata.message==ARRAY_CONTINUE); mean/=n; array_previousvector(&indata); do { if ((args[ARGS_EXCLUDEOTHER].is_set && !is_in_channellist(indata.current_element+1, rereference_args->refchannel_numbers)) || is_in_channellist(indata.current_element+1, rereference_args->excludechannel_numbers)) { array_advance(&indata); } else { array_write(&indata, READ_ELEMENT(&indata)-mean); } } while (indata.message==ARRAY_CONTINUE); } while (indata.message!=ARRAY_ENDOFSCAN); } return tinfo->tsdata; }
GLOBAL void array_tqli(array *d, array *e, array *z) { int n=d->nr_of_elements,m,l,iter,i,k; DATATYPE s,r,p,g,f,dd,c,b,hold; for (i=1;i<n;i++) { e->current_element=i; hold=READ_ELEMENT(e); e->current_element=i-1; WRITE_ELEMENT(e, hold); } e->current_element=n-1; WRITE_ELEMENT(e, 0.0); for (l=0;l<n;l++) { iter=0; do { for (m=l;m<n-1;m++) { /*{{{}}}*/ /*{{{ */ d->current_element=e->current_element=m; hold=fabs(READ_ELEMENT(d)); d->current_element=m+1; dd=hold+fabs(READ_ELEMENT(d)); if ((DATATYPE)(fabs(READ_ELEMENT(e))+dd) == dd) break; /*}}} */ } if (m != l) { /*{{{ */ if (iter++ == 30) nrerror("Too many iterations in tqli"); d->current_element=l+1; hold=READ_ELEMENT(d); d->current_element=e->current_element=l; g=(hold-READ_ELEMENT(d))/(2.0*READ_ELEMENT(e)); r=pythag(g,1.0); hold=READ_ELEMENT(d); d->current_element=m; g=READ_ELEMENT(d)-hold+READ_ELEMENT(e)/(g+SIGN(r,g)); s=c=1.0; p=0.0; for (i=m-1;i>=l;i--) { e->current_element=i; hold=READ_ELEMENT(e); f=s*hold; b=c*hold; e->current_element=d->current_element=i+1; WRITE_ELEMENT(e, r=pythag(f,g)); if (r == 0.0) { WRITE_ELEMENT(d, READ_ELEMENT(d)-p); e->current_element=m; WRITE_ELEMENT(e, 0.0); break; } s=f/r; c=g/r; g=READ_ELEMENT(d)-p; d->current_element=i; r=(READ_ELEMENT(d)-g)*s+2.0*c*b; d->current_element=i+1; WRITE_ELEMENT(d, g+(p=s*r)); g=c*r-b; for (k=0;k<n;k++) { z->current_element=k; z->current_vector=i+1; f=READ_ELEMENT(z); z->current_vector=i; hold=READ_ELEMENT(z); z->current_vector=i+1; WRITE_ELEMENT(z, s*hold+c*f); z->current_vector=i; WRITE_ELEMENT(z, c*hold-s*f); } } if (r == 0.0 && i >= l) continue; d->current_element=e->current_element=l; WRITE_ELEMENT(d, READ_ELEMENT(d)-p); WRITE_ELEMENT(e, g); e->current_element=m; WRITE_ELEMENT(e, 0.0); /*}}} */ } } while (m != l); } }
int main(int argc, char **argv) { FILE *fp; surfspline_desc sspline; int err, npoints, itempart=0; int binary_output=FALSE, matlab_output=FALSE, mtv_output=FALSE, interpolate_only=FALSE; float fbuf, external_value=0.0; DATATYPE f, x, y, xmin, xmax, ymin, ymax, xstep, ystep; array index; pid_t pid; char outname[L_tmpnam], inname[L_tmpnam], **inargs, *infile; /*{{{ Read command line args*/ for (inargs=argv+1; inargs-argv<argc && **inargs=='-'; inargs++) { switch(inargs[0][1]) { case 'B': binary_output=TRUE; break; case 'I': if (inargs[0][2]!='\0') { itempart=atoi(*inargs+2); } break; case 'i': interpolate_only=TRUE; if (inargs[0][2]!='\0') { external_value=atof(*inargs+2); } break; case 'M': matlab_output=TRUE; break; case 'm': mtv_output=TRUE; break; default: fprintf(stderr, "%s: Ignoring unknown option %s\n", argv[0], *inargs); continue; } } if (argc-(inargs-argv)!=3) { fprintf(stderr, "Usage: %s array_filename degree npoints\n" "Options:\n" " -Iitem: Use item number item as z-axis (2+item'th column); default: 0\n" " -i[value]: Interpolate only; set external values to value (default: 0.0)\n" " -B: Binary output (gnuplot floats)\n" " -M: Matlab output (x, y vectors and z matrix)\n" " -m: Plotmtv output\n" , argv[0]); return -1; } infile= *inargs++; if ((fp=fopen(infile, "r"))==NULL) { fprintf(stderr, "Can't open %s\n", infile); return -2; } array_undump(fp, &sspline.inpoints); fclose(fp); if (sspline.inpoints.message==ARRAY_ERROR) { fprintf(stderr, "Error in array_undump\n"); return -3; } if (sspline.inpoints.nr_of_elements<3+itempart) { fprintf(stderr, "Not enough columns in array %s\n", *(inargs-1)); return -3; } sspline.degree=atoi(*inargs++);; npoints=atoi(*inargs++); /*}}} */ /*{{{ Get the index of qhull point pairs by running qhull*/ tmpnam(outname); tmpnam(inname); if ((pid=fork())==0) { /* I'm the child */ #define LINEBUF_SIZE 128 char linebuf[LINEBUF_SIZE]; array tmp_array; /*{{{ Dump xy positions to tmp file inname*/ tmp_array.nr_of_elements=2; tmp_array.nr_of_vectors=sspline.inpoints.nr_of_vectors; tmp_array.element_skip=1; if (array_allocate(&tmp_array)==NULL) { fprintf(stderr, "Error allocating tmp_array\n"); return -4; } array_reset(&sspline.inpoints); do { array_write(&tmp_array, array_scan(&sspline.inpoints)); array_write(&tmp_array, array_scan(&sspline.inpoints)); array_nextvector(&sspline.inpoints); } while (tmp_array.message!=ARRAY_ENDOFSCAN); if ((fp=fopen(inname, "w"))==NULL) { fprintf(stderr, "Can't open %s\n", inname); return -5; } array_dump(fp, &tmp_array, ARRAY_ASCII); fclose(fp); array_free(&tmp_array); /*}}} */ snprintf(linebuf, LINEBUF_SIZE, "qhull C0 i b <%s >%s", inname, outname); execl("/bin/sh", "sh", "-c", linebuf, 0); #undef LINEBUF_SIZE } else { wait(NULL); } unlink(inname); if ((fp=fopen(outname, "r"))==NULL) { fprintf(stderr, "Can't open %s\n", outname); return -6; } array_undump(fp, &index); fclose(fp); unlink(outname); /*}}} */ /*{{{ Find min, max and mean coordinates*/ array_transpose(&sspline.inpoints); array_reset(&sspline.inpoints); xmin=array_min(&sspline.inpoints); ymin=array_min(&sspline.inpoints); array_reset(&sspline.inpoints); xmax=array_max(&sspline.inpoints); ymax=array_max(&sspline.inpoints); array_reset(&sspline.inpoints); xmean=array_mean(&sspline.inpoints); ymean=array_mean(&sspline.inpoints); xstep=(xmax-xmin)/npoints; ystep=(ymax-ymin)/npoints; array_transpose(&sspline.inpoints); array_reset(&sspline.inpoints); /*}}} */ /*{{{ Copy itempart to 3rd location if necessary*/ /* Note: For this behavior it is essential that array_surfspline * will accept vectors of any size >=3 and only process the first three * elements ! */ if (itempart>0) { DATATYPE hold; do { sspline.inpoints.current_element=2+itempart; hold=READ_ELEMENT(&sspline.inpoints); sspline.inpoints.current_element=2; WRITE_ELEMENT(&sspline.inpoints, hold); array_nextvector(&sspline.inpoints); } while (sspline.inpoints.message!=ARRAY_ENDOFSCAN); } /*}}} */ /*{{{ Do surface spline*/ if ((err=array_surfspline(&sspline))!=0) { fprintf(stderr, "Error %d in array_surfspline\n", err); return err; } xmin-=xstep; xmax+=2*xstep; ymin-=ystep; ymax+=2*ystep; if (binary_output) { /*{{{ Gnuplot binary output*/ int n_xval=(xmax-xmin)/xstep+1, n; /* Number of x values */ fbuf=n_xval; fwrite(&fbuf, sizeof(float), 1, stdout); for (fbuf=xmin, n=0; n<n_xval; fbuf+=xstep, n++) { /* x values */ fwrite(&fbuf, sizeof(float), 1, stdout); } for (y=ymin; y<=ymax; y+=ystep) { fbuf=y; fwrite(&fbuf, sizeof(float), 1, stdout); for (x=xmin, n=0; n<n_xval; x+=xstep, n++) { if (interpolate_only && !is_inside(&index, &sspline.inpoints, x, y)) { f=external_value; } else { f=array_fsurfspline(&sspline, x, y); } fbuf=f; fwrite(&fbuf, sizeof(float), 1, stdout); } } /*}}} */ } else if (matlab_output) { /*{{{ Matlab output*/ array xm, ym, zm; xm.nr_of_elements=ym.nr_of_elements=1; xm.nr_of_vectors=zm.nr_of_elements=(xmax-xmin)/xstep+1; ym.nr_of_vectors=zm.nr_of_vectors=(ymax-ymin)/ystep+1; xm.element_skip=ym.element_skip=zm.element_skip=1; array_allocate(&xm); array_allocate(&ym); array_allocate(&zm); if (xm.message==ARRAY_ERROR || ym.message==ARRAY_ERROR || zm.message==ARRAY_ERROR) { fprintf(stderr, "Error allocating output arrays\n"); return -7; } x=xmin; do { array_write(&xm, x); x+=xstep; } while (xm.message!=ARRAY_ENDOFSCAN); y=ymin; do { array_write(&ym, y); x=xmin; do { if (interpolate_only && !is_inside(&index, &sspline.inpoints, x, y)) { f=external_value; } else { f=array_fsurfspline(&sspline, x, y); } array_write(&zm, f); x+=xstep; } while (zm.message==ARRAY_CONTINUE); y+=ystep; } while (zm.message!=ARRAY_ENDOFSCAN); array_dump(stdout, &xm, ARRAY_MATLAB); array_dump(stdout, &ym, ARRAY_MATLAB); array_dump(stdout, &zm, ARRAY_MATLAB); array_free(&xm); array_free(&ym); array_free(&zm); /*}}} */ } else if (mtv_output) { /*{{{ Plotmtv output*/ array zm; DATATYPE zmin=FLT_MAX, zmax= -FLT_MAX; zm.nr_of_elements=(xmax-xmin)/xstep+1; zm.nr_of_vectors=(ymax-ymin)/ystep+1; zm.element_skip=1; array_allocate(&zm); if (zm.message==ARRAY_ERROR) { fprintf(stderr, "Error allocating output arrays\n"); return -7; } y=ymin; do { x=xmin; do { if (interpolate_only && !is_inside(&index, &sspline.inpoints, x, y)) { f=external_value; } else { f=array_fsurfspline(&sspline, x, y); } array_write(&zm, f); if (f<zmin) zmin=f; if (f>zmax) zmax=f; x+=xstep; } while (zm.message==ARRAY_CONTINUE); y+=ystep; } while (zm.message!=ARRAY_ENDOFSCAN); /*{{{ Print file header*/ printf( "# Output of Spline_Gridder (C) Bernd Feige 1995\n\n" "$ DATA=CONTOUR\n\n" "%% toplabel = \"Spline_Gridder output\"\n" "%% subtitle = \"File: %s\"\n\n" "%% interp = 0\n" "%% contfill = on\n" "%% meshplot = off\n\n" "%% xmin = %g xmax = %g\n" "%% ymin = %g ymax = %g\n" "%% zmin = %g zmax = %g\n" "%% nx = %d\n" "%% ny = %d\n" , infile, xmin, xmax, ymin, ymax, zmin, zmax, zm.nr_of_elements, zm.nr_of_vectors); /*}}} */ array_dump(stdout, &zm, ARRAY_MATLAB); array_free(&zm); /*}}} */ } else { /*{{{ Gnuplot output*/ for (x=xmin; x<=xmax; x+=xstep) { for (y=ymin; y<=ymax; y+=ystep) { if (interpolate_only && !is_inside(&index, &sspline.inpoints, x, y)) { f=external_value; } else { f=array_fsurfspline(&sspline, x, y); } printf("%g %g %g\n", x, y, f); } printf("\n"); } /*}}} */ } /*}}} */ return 0; }
/*{{{ normalize_channelbox(transform_info_ptr tinfo) {*/ METHODDEF DATATYPE * normalize_channelbox(transform_info_ptr tinfo) { struct normalize_channelbox_storage *local_arg=(struct normalize_channelbox_storage *)tinfo->methods->local_storage; transform_argument *args=tinfo->methods->arguments; transform_info_ptr const tinfoptr=tinfo; int channel, xmaxchan, xminchan, ymaxchan, yminchan, zmaxchan, zminchan; DATATYPE value, value2, xmax, ymax, zmax, xmin, ymin, zmin, xmid, ymid, zmid; DATATYPE tval[9]; double phi; array myarray, t; local_arg->view_from_left=FALSE; /*{{{ Construct array myarray*/ myarray.start=(DATATYPE *)tinfoptr->probepos; myarray.nr_of_elements=3; myarray.nr_of_vectors=tinfoptr->nr_of_channels; myarray.vector_skip=3; myarray.element_skip=1; array_setreadwrite_double(&myarray); /*}}} */ /*{{{ Swap x and y if data set is 'Roma' (x=left->right)*/ if (strncmp(tinfo->comment, "Roma ", 5)==0) { /* This is the trace that vp2mfx leaves in Roma files. Though generality * lacks, this seems unavoidable in this module */ array_reset(&myarray); do { value=array_scan(&myarray); value2=array_scan(&myarray); myarray.current_element=0; array_write(&myarray, value2); array_write(&myarray, -value); array_advance(&myarray); } while (myarray.message!=ARRAY_ENDOFSCAN); } /*}}} */ /*{{{ Find min and max values of the box*/ array_reset(&myarray); xmax=xmin=array_scan(&myarray); ymax=ymin=array_scan(&myarray); zmax=zmin=array_scan(&myarray); xmaxchan=xminchan=ymaxchan=yminchan=zmaxchan=zminchan=0; channel=1; do { value=array_scan(&myarray); if (value>xmax) { xmax=value; xmaxchan=channel; } if (value<xmin) { xmin=value; xminchan=channel; } value=array_scan(&myarray); if (value>ymax) { ymax=value; ymaxchan=channel; } if (value<ymin) { ymin=value; yminchan=channel; } value=array_scan(&myarray); if (value>zmax) { zmax=value; zmaxchan=channel; } if (value<zmin) { zmin=value; zminchan=channel; } channel++; } while (myarray.message!=ARRAY_ENDOFSCAN); # ifdef DEBUG printf("zmaxchan=%s, xmaxchan=%s\n", tinfoptr->channelnames[zmaxchan], tinfoptr->channelnames[xmaxchan]); # endif /*}}} */ /*{{{ Subtract midpoint*/ xmid=(xmax+xmin)/2; ymid=(ymax+ymin)/2; zmid=(zmax+zmin)/2; # ifdef DEBUG printf("xmid=%g, ymid=%g, zmid=%g\n", xmid, ymid, zmid); # endif array_reset(&myarray); do { array_write(&myarray, READ_ELEMENT(&myarray)-xmid); array_write(&myarray, READ_ELEMENT(&myarray)-ymid); array_write(&myarray, READ_ELEMENT(&myarray)-zmid); } while (myarray.message!=ARRAY_ENDOFSCAN); /*}}} */ /*{{{ Construct array t to be used for rotations*/ t.start=tval; t.nr_of_elements=3; t.nr_of_vectors=3; t.element_skip=1; t.vector_skip=3; array_setreadwrite(&t); /*}}} */ /*{{{ rotate zmaxchan about the x axis by its angle to the y axis (maximize y)*/ /* By this rotation, the z component of zmaxchan is removed. */ array_reset(&t); myarray.current_vector=zmaxchan; myarray.current_element=1; value=array_scan(&myarray); /* y value */ value2=READ_ELEMENT(&myarray); /* z value */ value/=sqrt(value*value+value2*value2); phi=(value2>0 ? -acos(value) : acos(value)); # ifdef DEBUG printf("z=%g, cos phi=%g=%g, phi=%g\n", value2, value, cos(phi), phi); # endif array_write(&t, 1.0); array_write(&t, 0.0); array_write(&t, 0.0); array_write(&t, 0.0); array_write(&t, cos(phi)); array_write(&t, sin(phi)); array_write(&t, 0.0); array_write(&t, -sin(phi)); array_write(&t, cos(phi)); array_transpose(&t); array_reset(&myarray); do { DATATYPE x, y, z; x=array_multiply(&t, &myarray, MULT_SAMESIZE); y=array_multiply(&t, &myarray, MULT_SAMESIZE); z=array_multiply(&t, &myarray, MULT_SAMESIZE); array_previousvector(&myarray); array_write(&myarray, x); array_write(&myarray, y); array_write(&myarray, z); } while (myarray.message!=ARRAY_ENDOFSCAN); /*}}} */ /*{{{ rotate zmaxchan about the z axis by its angle to the y axis (maximize y)*/ /* Now remove the x component of zmaxchan. Coordinates should be 0, z, 0 */ array_reset(&t); myarray.current_element=0; myarray.current_vector=zmaxchan; value2=array_scan(&myarray); /* x value */ value=READ_ELEMENT(&myarray); /* y value */ value/=sqrt(value*value+value2*value2); phi=(value2>0 ? -acos(value) : acos(value)); # ifdef DEBUG printf("z=%g, cos phi=%g=%g, phi=%g\n", value2, value, cos(phi), phi); # endif array_write(&t, cos(phi)); array_write(&t, sin(phi)); array_write(&t, 0.0); array_write(&t, -sin(phi)); array_write(&t, cos(phi)); array_write(&t, 0.0); array_write(&t, 0.0); array_write(&t, 0.0); array_write(&t, 1.0); if (value2<0.0) array_transpose(&t); array_reset(&myarray); do { DATATYPE x, y, z; x=array_multiply(&t, &myarray, MULT_SAMESIZE); y=array_multiply(&t, &myarray, MULT_SAMESIZE); z=array_multiply(&t, &myarray, MULT_SAMESIZE); array_previousvector(&myarray); array_write(&myarray, x); array_write(&myarray, y); array_write(&myarray, z); } while (myarray.message!=ARRAY_ENDOFSCAN); /*}}} */ /*{{{ rotate xmaxchan about the y axis by its angle to the x axis (maximize x)*/ /* This is the only rotation that will leave zmaxchan at its position */ array_reset(&t); myarray.current_element=0; myarray.current_vector=(args[ARGS_DECIDE_LEFTRIGHT].is_set && ymid>0.0 ? local_arg->view_from_left=TRUE,xminchan : xmaxchan); value=array_scan(&myarray); /* x value */ array_advance(&myarray); value2=READ_ELEMENT(&myarray); /* z value */ value/=sqrt(value*value+value2*value2); phi=(value2>0 ? -acos(value) : acos(value)); # ifdef DEBUG printf("z=%g, cos phi=%g=%g, phi=%g\n", value2, value, cos(phi), phi); # endif array_write(&t, cos(phi)); array_write(&t, 0.0); array_write(&t, -sin(phi)); array_write(&t, 0.0); array_write(&t, 1.0); array_write(&t, 0.0); array_write(&t, sin(phi)); array_write(&t, 0.0); array_write(&t, cos(phi)); if (value2<0.0) array_transpose(&t); array_reset(&myarray); do { DATATYPE x, y, z; x=array_multiply(&t, &myarray, MULT_SAMESIZE); y=array_multiply(&t, &myarray, MULT_SAMESIZE); z=array_multiply(&t, &myarray, MULT_SAMESIZE); array_previousvector(&myarray); array_write(&myarray, x); array_write(&myarray, y); array_write(&myarray, z); } while (myarray.message!=ARRAY_ENDOFSCAN); /*}}} */ return tinfo->tsdata; }
GLOBAL void array_tred2(array *a, array *d, array *e) { int n=a->nr_of_elements,l,k,j,i; DATATYPE scale,hh,h,g,f,hold; for (i=n-1;i>=1;i--) { l=i-1; h=scale=0.0; if (l > 0) { /*{{{}}}*/ /*{{{ */ a->current_element=i; for (k=0;k<=l;k++) { a->current_vector=k; scale += fabs(READ_ELEMENT(a)); } if (scale == 0.0) { a->current_vector=l; e->current_element=i; WRITE_ELEMENT(e, READ_ELEMENT(a)); } else { /*{{{ */ a->current_element=i; for (k=0;k<=l;k++) { a->current_vector=k; WRITE_ELEMENT(a, hold=READ_ELEMENT(a)/scale); h += hold*hold; } a->current_vector=l; f=READ_ELEMENT(a); g=(f >= 0.0 ? -sqrt(h) : sqrt(h)); e->current_element=i; WRITE_ELEMENT(e, scale*g); h -= f*g; WRITE_ELEMENT(a, f-g); f=0.0; for (j=0;j<=l;j++) { a->current_element=i; a->current_vector=j; hold=READ_ELEMENT(a); a->current_element=j; a->current_vector=i; WRITE_ELEMENT(a, hold/h); g=0.0; for (k=0;k<=j;k++) { a->current_element=j; a->current_vector=k; hold=READ_ELEMENT(a); a->current_element=i; a->current_vector=k; g += hold*READ_ELEMENT(a); } for (k=j+1;k<=l;k++) { a->current_element=k; a->current_vector=j; hold=READ_ELEMENT(a); a->current_element=i; a->current_vector=k; g += hold*READ_ELEMENT(a); } e->current_element=j; WRITE_ELEMENT(e, hold=g/h); a->current_element=i; a->current_vector=j; f += hold*READ_ELEMENT(a); } hh=f/(h+h); for (j=0;j<=l;j++) { a->current_element=i; a->current_vector=j; f=READ_ELEMENT(a); e->current_element=j; g=READ_ELEMENT(e)-hh*f; WRITE_ELEMENT(e, g); for (k=0;k<=j;k++) { a->current_element=i; a->current_vector=k; hold=READ_ELEMENT(a); a->current_element=j; a->current_vector=k; e->current_element=k; hold=f*READ_ELEMENT(e)+g*hold; WRITE_ELEMENT(a, READ_ELEMENT(a)-hold); } } /*}}} */ } /*}}} */ } else { /*{{{ */ e->current_element=a->current_element=i; a->current_vector=l; WRITE_ELEMENT(e, READ_ELEMENT(a)); /*}}} */ } d->current_element=i; WRITE_ELEMENT(d, h); } d->current_element=0; WRITE_ELEMENT(d, 0.0); e->current_element=0; WRITE_ELEMENT(e, 0.0); for (i=0;i<n;i++) { l=i-1; d->current_element=i; if (READ_ELEMENT(d)) { for (j=0;j<=l;j++) { g=0.0; for (k=0;k<=l;k++) { a->current_element=i; a->current_vector=k; hold=READ_ELEMENT(a); a->current_element=k; a->current_vector=j; g += hold*READ_ELEMENT(a); } for (k=0;k<=l;k++) { a->current_element=k; a->current_vector=i; hold=READ_ELEMENT(a); a->current_element=k; a->current_vector=j; WRITE_ELEMENT(a, READ_ELEMENT(a)-g*hold); } } } a->current_element=i; a->current_vector=i; WRITE_ELEMENT(d, READ_ELEMENT(a)); WRITE_ELEMENT(a, 1.0); for (j=0;j<=l;j++) { a->current_element=j; a->current_vector=i; WRITE_ELEMENT(a, 0.0); a->current_element=i; a->current_vector=j; WRITE_ELEMENT(a, 0.0); } } }
/*{{{ project_init(transform_info_ptr tinfo)*/ METHODDEF void project_init(transform_info_ptr tinfo) { struct project_args_struct *project_args=(struct project_args_struct *)tinfo->methods->local_storage; transform_argument *args=tinfo->methods->arguments; transform_info_ptr side_tinfo= &project_args->side_tinfo; array *vectors= &project_args->vectors; growing_buf buf; #define BUFFER_SIZE 80 char buffer[BUFFER_SIZE]; side_tinfo->methods= &project_args->methods; side_tinfo->emethods=tinfo->emethods; select_readasc(side_tinfo); growing_buf_init(&buf); growing_buf_allocate(&buf, 0); if (args[ARGS_FROMEPOCH].is_set) { snprintf(buffer, BUFFER_SIZE, "-f %ld ", args[ARGS_FROMEPOCH].arg.i); growing_buf_appendstring(&buf, buffer); } if (args[ARGS_EPOCHS].is_set) { project_args->epochs=args[ARGS_EPOCHS].arg.i; if (project_args->epochs<=0) { ERREXIT(tinfo->emethods, "project_init: The number of epochs must be positive.\n"); } } else { project_args->epochs=1; } snprintf(buffer, BUFFER_SIZE, "-e %d ", project_args->epochs); growing_buf_appendstring(&buf, buffer); growing_buf_appendstring(&buf, args[ARGS_PROJECTFILE].arg.s); if (!buf.can_be_freed || !setup_method(side_tinfo, &buf)) { ERREXIT(tinfo->emethods, "project_init: Error setting readasc arguments.\n"); } project_args->points=(args[ARGS_POINTS].is_set ? args[ARGS_POINTS].arg.i : 1); project_args->nr_of_item=(args[ARGS_NROFITEM].is_set ? args[ARGS_NROFITEM].arg.i : 0); project_args->orthogonalize_vectors_first=args[ARGS_ORTHOGONALIZE].is_set; if (args[ARGS_SUBSPACE].is_set) { project_args->project_mode=PROJECT_MODE_SSP; } else if (args[ARGS_SUBTRACT_SUBSPACE].is_set) { project_args->project_mode=PROJECT_MODE_SSPS; } else if (args[ARGS_MULTIPLY].is_set) { project_args->project_mode=PROJECT_MODE_MULTIPLY; } else { project_args->project_mode=PROJECT_MODE_SCALAR; } if (args[ARGS_CHANNELNAMES].is_set) { project_args->channel_list=expand_channel_list(tinfo, args[ARGS_CHANNELNAMES].arg.s); if (project_args->channel_list==NULL) { ERREXIT(tinfo->emethods, "project_init: Zero channels were selected by -N!\n"); } } else { project_args->channel_list=NULL; } (*side_tinfo->methods->transform_init)(side_tinfo); /*{{{ Read first project_file epoch and allocate vectors array accordingly*/ if ((side_tinfo->tsdata=(*side_tinfo->methods->transform)(side_tinfo))==NULL) { ERREXIT(tinfo->emethods, "project_init: Can't get the first project epoch.\n"); } if (project_args->project_mode==PROJECT_MODE_MULTIPLY) { /* Save channel names and positions for later */ project_args->save_side_tinfo.nr_of_channels=side_tinfo->nr_of_channels; copy_channelinfo(&project_args->save_side_tinfo, side_tinfo->channelnames, side_tinfo->probepos); } if (project_args->points==0) project_args->points=side_tinfo->nr_of_points; if (project_args->points>side_tinfo->nr_of_points) { ERREXIT1(tinfo->emethods, "project_init: There are only %d points in the project_file epoch.\n", MSGPARM(side_tinfo->nr_of_points)); } if (args[ARGS_AT_XVALUE].is_set) { project_args->nr_of_point=find_pointnearx(side_tinfo, (DATATYPE)atof(args[ARGS_NROFPOINT].arg.s)); } else { project_args->nr_of_point=gettimeslice(side_tinfo, args[ARGS_NROFPOINT].arg.s); } vectors->nr_of_vectors=project_args->epochs*project_args->points; vectors->nr_of_elements=side_tinfo->nr_of_channels; vectors->element_skip=1; if (array_allocate(vectors)==NULL) { ERREXIT(tinfo->emethods, "project_init: Error allocating vectors memory\n"); } /*}}} */ do { /*{{{ Copy [points] vectors from project_file to vectors array*/ array indata; int point; if (vectors->nr_of_elements!=side_tinfo->nr_of_channels) { ERREXIT(side_tinfo->emethods, "project_init: Varying channel numbers in project file!\n"); } if (project_args->nr_of_point>=side_tinfo->nr_of_points) { ERREXIT2(side_tinfo->emethods, "project_init: nr_of_point=%d, nr_of_points=%d\n", MSGPARM(project_args->nr_of_point), MSGPARM(side_tinfo->nr_of_points)); } if (project_args->nr_of_item>=side_tinfo->itemsize) { ERREXIT2(side_tinfo->emethods, "project_init: nr_of_item=%d, itemsize=%d\n", MSGPARM(project_args->nr_of_item), MSGPARM(side_tinfo->itemsize)); } for (point=0; point<project_args->points; point++) { tinfo_array(side_tinfo, &indata); array_transpose(&indata); /* Vector = map */ if (vectors->nr_of_elements!=indata.nr_of_elements) { ERREXIT(side_tinfo->emethods, "project_init: vector size doesn't match\n"); } indata.current_vector=project_args->nr_of_point+point; array_setto_vector(&indata); array_use_item(&indata, project_args->nr_of_item); array_copy(&indata, vectors); } /*}}} */ free_tinfo(side_tinfo); } while ((side_tinfo->tsdata=(*side_tinfo->methods->transform)(side_tinfo))!=NULL); if (vectors->message!=ARRAY_ENDOFSCAN) { ERREXIT1(tinfo->emethods, "project_init: Less than %d epochs in project file\n", MSGPARM(vectors->nr_of_vectors)); } /*{{{ Set unused channels to zero if requested*/ if (args[ARGS_ZERO_UNUSEDCOEFFICIENTS].is_set) { if (project_args->channel_list!=NULL) { do { do { if (is_in_channellist(vectors->current_element+1, project_args->channel_list)) { array_advance(vectors); } else { array_write(vectors, 0.0); } } while (vectors->message==ARRAY_CONTINUE); } while (vectors->message!=ARRAY_ENDOFSCAN); } else { ERREXIT(tinfo->emethods, "project_init: Option -z only makes sense in combination with -N!\n"); } } /*}}} */ /*{{{ De-mean vectors if requested*/ if (args[ARGS_CORRELATION].is_set) { do { DATATYPE mean=0.0; int nrofaverages=0; do { if (project_args->channel_list!=NULL && !is_in_channellist(vectors->current_element+1, project_args->channel_list)) { array_advance(vectors); } else { mean+=array_scan(vectors); nrofaverages++; } } while (vectors->message==ARRAY_CONTINUE); mean/=nrofaverages; array_previousvector(vectors); do { array_write(vectors, READ_ELEMENT(vectors)-mean); } while (vectors->message==ARRAY_CONTINUE); } while (vectors->message!=ARRAY_ENDOFSCAN); } /*}}} */ /*{{{ Orthogonalize vectors if requested*/ if (project_args->orthogonalize_vectors_first) { array_make_orthogonal(vectors); if (vectors->message==ARRAY_ERROR) { ERREXIT(tinfo->emethods, "project_init: Error orthogonalizing projection vectors\n"); } } /*}}} */ if (!args[ARGS_NONORMALIZATION].is_set) { /*{{{ Normalize vectors*/ do { DATATYPE length=0.0; do { if (project_args->channel_list!=NULL && !is_in_channellist(vectors->current_element+1, project_args->channel_list)) { array_advance(vectors); } else { const DATATYPE hold=array_scan(vectors); length+=hold*hold; } } while (vectors->message==ARRAY_CONTINUE); length=sqrt(length); array_previousvector(vectors); if (length==0.0) { ERREXIT1(tinfo->emethods, "project_init: Vector %d has zero length !\n", MSGPARM(vectors->current_vector)); } array_scale(vectors, 1.0/length); } while (vectors->message!=ARRAY_ENDOFSCAN); /*}}} */ } /*{{{ Dump vectors if requested*/ if (args[ARGS_DUMPVECTORS].is_set) { FILE * const fp=fopen(args[ARGS_DUMPVECTORS].arg.s, "w"); if (fp==NULL) { ERREXIT1(tinfo->emethods, "project_init: Error opening output file >%s<.\n", MSGPARM(args[ARGS_DUMPVECTORS].arg.s)); } array_transpose(vectors); /* We want one vector to be one column */ array_dump(fp, vectors, ARRAY_MATLAB); array_transpose(vectors); fclose(fp); } /*}}} */ (*side_tinfo->methods->transform_exit)(side_tinfo); free_methodmem(side_tinfo); growing_buf_free(&buf); tinfo->methods->init_done=TRUE; }
/*{{{ project(transform_info_ptr tinfo)*/ METHODDEF DATATYPE * project(transform_info_ptr tinfo) { struct project_args_struct *project_args=(struct project_args_struct *)tinfo->methods->local_storage; transform_argument *args=tinfo->methods->arguments; DATATYPE *retvalue=tinfo->tsdata; array indata, scalars, *vectors= &project_args->vectors; int itempart, itemparts=tinfo->itemsize-tinfo->leaveright; if (project_args->project_mode==PROJECT_MODE_MULTIPLY) { if (!(tinfo->nr_of_channels==vectors->nr_of_vectors ||(tinfo->nr_of_channels==1 && tinfo->itemsize==vectors->nr_of_vectors))) { ERREXIT(tinfo->emethods, "project: Number of scalars and maps doesn't match!\n"); } } else { if (vectors->nr_of_elements!=tinfo->nr_of_channels) { ERREXIT2(tinfo->emethods, "project: %d channels in epoch, but %d channels in project file.\n", MSGPARM(tinfo->nr_of_channels), MSGPARM(vectors->nr_of_elements)); } } array_reset(vectors); tinfo_array(tinfo, &indata); array_transpose(&indata); /* Vectors are maps */ /* Be sure that different output items are adjacent... */ scalars.nr_of_elements=vectors->nr_of_vectors; switch (project_args->project_mode) { case PROJECT_MODE_SCALAR: scalars.nr_of_vectors=tinfo->nr_of_points; scalars.element_skip=itemparts; break; case PROJECT_MODE_SSP: case PROJECT_MODE_SSPS: scalars.nr_of_vectors=1; scalars.element_skip=1; break; case PROJECT_MODE_MULTIPLY: scalars=indata; if (tinfo->nr_of_channels!=vectors->nr_of_vectors) { /* Ie, one channel and weights in the items: Convert from 1 element to * itemsize elements */ scalars.element_skip=1; scalars.nr_of_elements=tinfo->itemsize; itemparts=1; } indata.element_skip=itemparts; indata.nr_of_elements=vectors->nr_of_elements; /* New number of channels */ indata.nr_of_vectors=scalars.nr_of_vectors; /* New number of points */ if (array_allocate(&indata)==NULL) { ERREXIT(tinfo->emethods, "project: Can't allocate new indata array\n"); } break; } if (project_args->project_mode==PROJECT_MODE_MULTIPLY) { array_transpose(vectors); /* Now the elements are the subspace dimensions */ for (itempart=0; itempart<itemparts; itempart++) { array_use_item(&indata, itempart); array_use_item(&scalars, itempart); do { /*{{{ Build the signal subspace vector*/ do { array_write(&indata, array_multiply(vectors, &scalars, MULT_SAMESIZE)); } while (indata.message==ARRAY_CONTINUE); /*}}} */ } while (indata.message!=ARRAY_ENDOFSCAN); } array_transpose(vectors); } else { if (array_allocate(&scalars)==NULL) { ERREXIT(tinfo->emethods, "project: Can't allocate scalars array\n"); } for (itempart=0; itempart<itemparts; itempart++) { array_use_item(&indata, itempart); if (project_args->project_mode==PROJECT_MODE_SCALAR) { array_use_item(&scalars, itempart); } do { /*{{{ Calculate the projection scalars*/ do { /* With all vectors in turn: */ DATATYPE product=0.0; do { if (project_args->channel_list!=NULL && !is_in_channellist(vectors->current_element+1, project_args->channel_list)) { array_advance(vectors); array_advance(&indata); } else { product+=array_scan(&indata)*array_scan(vectors); } } while (vectors->message==ARRAY_CONTINUE); array_write(&scalars, product); if (scalars.message==ARRAY_CONTINUE) array_previousvector(&indata); } while (scalars.message==ARRAY_CONTINUE); /*}}} */ switch (project_args->project_mode) { case PROJECT_MODE_SCALAR: break; case PROJECT_MODE_SSP: /*{{{ Build the signal subspace vector*/ array_transpose(vectors); /* Now the elements are the subspace dimensions */ array_previousvector(&indata); do { array_write(&indata, array_multiply(vectors, &scalars, MULT_VECTOR)); } while (indata.message==ARRAY_CONTINUE); array_transpose(vectors); /*}}} */ break; case PROJECT_MODE_SSPS: /*{{{ Subtract the signal subspace vector*/ array_transpose(vectors); /* Now the elements are the subspace dimensions */ array_previousvector(&indata); do { array_write(&indata, READ_ELEMENT(&indata)-array_multiply(vectors, &scalars, MULT_VECTOR)); } while (indata.message==ARRAY_CONTINUE); array_transpose(vectors); /*}}} */ break; default: /* Can't happen, just to keep the compiler happy... */ ERREXIT(tinfo->emethods, "project: This cannot happen!\n"); break; } } while (indata.message!=ARRAY_ENDOFSCAN); } } /*{{{ Prepare tinfo to reflect the data structure returned*/ switch (project_args->project_mode) { case PROJECT_MODE_SCALAR: if (args[ARGS_USE_CHANNELS].is_set) { tinfo->nr_of_channels=vectors->nr_of_vectors; tinfo->itemsize=itemparts; } else { tinfo->nr_of_channels=1; tinfo->itemsize=itemparts*vectors->nr_of_vectors; } tinfo->length_of_output_region=scalars.nr_of_elements*scalars.element_skip*scalars.nr_of_vectors; tinfo->leaveright=0; tinfo->multiplexed=TRUE; if (tinfo->channelnames!=NULL) { free_pointer((void **)&tinfo->channelnames[0]); free_pointer((void **)&tinfo->channelnames); } free_pointer((void **)&tinfo->probepos); create_channelgrid(tinfo); retvalue=scalars.start; break; case PROJECT_MODE_SSP: case PROJECT_MODE_SSPS: array_free(&scalars); retvalue=tinfo->tsdata; break; case PROJECT_MODE_MULTIPLY: /* Note that we don't free `scalars' because it just points to the original tsdata! */ /* Have to set this correctly so that copy_channelinfo works... */ tinfo->nr_of_channels=indata.nr_of_elements; copy_channelinfo(tinfo, project_args->save_side_tinfo.channelnames, project_args->save_side_tinfo.probepos); tinfo->nr_of_points=indata.nr_of_vectors; tinfo->itemsize=indata.element_skip; tinfo->length_of_output_region=tinfo->nr_of_channels*tinfo->nr_of_points*tinfo->itemsize; retvalue=indata.start; tinfo->multiplexed=TRUE; break; } /*}}} */ return retvalue; }