HIDDEN int
under_sample(icv_image_t* bif, unsigned int factor)
{
double *data_p, *res_p;
int x, y, widthstep;
if (UNLIKELY(factor < 1)) {
bu_log("Cannot shrink image to 0 factor, factor should be a positive value.");
return -1;
}
widthstep = bif->width*bif->channels;
res_p = data_p = bif->data;
for (y = 0; y < bif->height; y += factor) {
data_p = bif->data + widthstep*y;
for (x = 0; x < bif->width;
x += factor, res_p += bif->channels, data_p += factor * bif->channels)
VMOVEN(res_p, data_p, bif->channels);
}
bif->width = (int)bif->width/factor;
bif->height = (int)bif->height/factor;
bif->data = (double *)bu_realloc(bif->data, (size_t)(bif->width*bif->height*bif->channels)*sizeof(double), "under_sample : Reallocation");
return 0;
}
HIDDEN int
ninterp(icv_image_t* bif, unsigned int out_width, unsigned int out_height)
{
double xstep, ystep;
unsigned int i, j;
int x, y;
int widthstep;
double *in_r, *in_c; /*<< Pointer to row and col of input buffers*/
double *out_data, *out_p;
xstep = (double)(bif->width-1) / (double)(out_width) - 1.0e-06;
ystep = (double)(bif->height-1) / (double)(out_height) - 1.0e-06;
if ((xstep < 1.0 && ystep > 1.0) || (xstep > 1.0 && ystep < 1.0)) {
bu_log("Operation unsupported. Cannot stretch one dimension while compressing the other.\n");
return -1;
}
out_p = out_data = (double *)bu_malloc(out_width*out_height*bif->channels*sizeof(double), "ninterp : out_data");
widthstep= bif->width*bif->channels;
for (j = 0; j < out_height; j++) {
y = (int)(j*ystep);
in_r = bif->data + y*widthstep;
for (i = 0; i < out_width; i++) {
x = (int)(i*xstep);
in_c = in_r + x*bif->channels;
VMOVEN(out_p, in_c, bif->channels);
out_p += bif->channels;
}
}
bu_free(bif->data, "ninterp : in_data");
bif->data = out_data;
bif->width = out_width;
bif->height = out_height;
return 0;
}
int
icv_writepixel(icv_image_t *bif, int x, int y, double *data)
{
double *dst;
ICV_IMAGE_VAL_INT(bif);
if (x > bif->width || x < 0)
return -1;
if (y > bif->height || y < 0)
return -1;
if (data == NULL)
return -1;
dst = bif->data + (y*bif->width + x)*bif->channels;
/* can copy float to double also double to double */
VMOVEN(dst, data, bif->channels);
return 0;
}
/**
* Given a pointer to an internal GED database object, mirror the
* object's values about the given transformation matrix.
*/
int
rt_nurb_mirror(struct rt_db_internal *ip, register const plane_t plane)
{
struct rt_nurb_internal *nurb;
mat_t mirmat;
mat_t rmat;
mat_t temp;
vect_t nvec;
vect_t xvec;
vect_t mirror_dir;
point_t mirror_pt;
fastf_t ang;
int i;
int j;
static point_t origin = {0.0, 0.0, 0.0};
RT_CK_DB_INTERNAL(ip);
nurb = (struct rt_nurb_internal *)ip->idb_ptr;
RT_PG_CK_MAGIC(nurb);
MAT_IDN(mirmat);
VMOVE(mirror_dir, plane);
VSCALE(mirror_pt, plane, plane[W]);
/* Build mirror transform matrix, for those who need it. */
/* First, perform a mirror down the X axis */
mirmat[0] = -1.0;
/* Create the rotation matrix */
VSET(xvec, 1, 0, 0);
VCROSS(nvec, xvec, mirror_dir);
VUNITIZE(nvec);
ang = -acos(VDOT(xvec, mirror_dir));
bn_mat_arb_rot(rmat, origin, nvec, ang*2.0);
/* Add the rotation to mirmat */
MAT_COPY(temp, mirmat);
bn_mat_mul(mirmat, temp, rmat);
/* Add the translation to mirmat */
mirmat[3 + X*4] += mirror_pt[X] * mirror_dir[X];
mirmat[3 + Y*4] += mirror_pt[Y] * mirror_dir[Y];
mirmat[3 + Z*4] += mirror_pt[Z] * mirror_dir[Z];
for (i=0; i<nurb->nsrf; i++) {
fastf_t *ptr;
int tmp;
int orig_size[2];
int ncoords;
int m;
int l;
/* swap knot vectors between u and v */
ptr = nurb->srfs[i]->u.knots;
tmp = nurb->srfs[i]->u.k_size;
nurb->srfs[i]->u.knots = nurb->srfs[i]->v.knots;
nurb->srfs[i]->u.k_size = nurb->srfs[i]->v.k_size;
nurb->srfs[i]->v.knots = ptr;
nurb->srfs[i]->v.k_size = tmp;
/* swap order */
tmp = nurb->srfs[i]->order[0];
nurb->srfs[i]->order[0] = nurb->srfs[i]->order[1];
nurb->srfs[i]->order[1] = tmp;
/* swap mesh size */
orig_size[0] = nurb->srfs[i]->s_size[0];
orig_size[1] = nurb->srfs[i]->s_size[1];
nurb->srfs[i]->s_size[0] = orig_size[1];
nurb->srfs[i]->s_size[1] = orig_size[0];
/* allocate memory for a new control mesh */
ncoords = RT_NURB_EXTRACT_COORDS(nurb->srfs[i]->pt_type);
ptr = (fastf_t *)bu_calloc(orig_size[0]*orig_size[1]*ncoords, sizeof(fastf_t), "rt_mirror: ctl mesh ptr");
/* mirror each control point */
for (j=0; j<orig_size[0]*orig_size[1]; j++) {
point_t pt;
VMOVE(pt, &nurb->srfs[i]->ctl_points[j*ncoords]);
MAT4X3PNT(&nurb->srfs[i]->ctl_points[j*ncoords], mirmat, pt);
}
/* copy mirrored control points into new mesh
* while swapping u and v */
m = 0;
for (j=0; j<orig_size[0]; j++) {
for (l=0; l<orig_size[1]; l++) {
VMOVEN(&ptr[(l*orig_size[0]+j)*ncoords], &nurb->srfs[i]->ctl_points[m*ncoords], ncoords);
m++;
}
}
/* free old mesh */
bu_free((char *)nurb->srfs[i]->ctl_points, "rt_mirror: ctl points");
/* put new mesh in place */
nurb->srfs[i]->ctl_points = ptr;
}
return 0;
}
int
main(int argc, char *argv[])
{
int count, status, num_read, enn, i, pp;
fastf_t *points, *cur;
fastf_t yaw, pch, rll, stepsize;
/* intentionally double for scan */
double first[4];
double second[4];
double scan[4];
if (argc == 1 && isatty(fileno(stdin)) && isatty(fileno(stdout))) {
usage();
return 0;
}
if (!get_args(argc, argv)) {
usage();
return 0;
}
yaw = pch = rll = 0.0;
/* read first two lines of table to determine the time step used */
/* (a constant time step is assumed throughout the rest of the file)*/
count = scanf("%lf %lf %lf %lf", first, first+1, first+2, first+3);
count += scanf("%lf %lf %lf %lf", second, second+1, second+2, second+3);
stepsize = second[0]-first[0];
if (count != 8) {
bu_exit(1, "%s: ERROR: expecting at least eight values (in the first two lines of the table) to determine the time step used\n", argv[0]);
}
/* determine n, the number of points to store ahead and behind the
* current point. 2n points are stored, minimum enn=2
*/
enn = (int) (desired_step/stepsize);
CLAMP(enn, 1, MAXN);
/* allocate storage */
points = (fastf_t *) bu_calloc((3*enn+1)*4, sizeof(fastf_t), "points");
/* read the first 3n points into the storage array*/
VMOVEN(points+4, first, 4);
VMOVEN(points+8, second, 4);
num_read=4; /* in order to pass test if n=1 */
for (cur=points+12; cur<points+(4*(3*enn+1)); cur+=4) {
num_read=scanf("%lf %lf %lf %lf", &scan[0], &scan[1], &scan[2], &scan[3]);
/* convert double to fastf_t */
HMOVE(cur, scan);
}
if (num_read<4) {
fprintf(stderr, "Anim_fly: Not enough lines in input table.\n");
fprintf(stderr, "Increase number of lines or reduce the minimum stepsize with -s.\n");
fprintf(stderr, "Currently the minimum step size is %g seconds.\n", desired_step);
return 0;
}
max_cross = 0;
count = 0;
pp = 0;
status = START;
while (status != STOP) {
switch (status) {
case START: /* first n points */
pp += 4;
get_orientation(points+pp, points+pp+4*enn, points+pp+4*2*enn, f_prm_0, &yaw, &pch, &rll);
if (!(count%print_int)&&!estimate_f) {
printf("%.10g\t%.10g\t%.10g\t%.10g\t%.10g\t%.10g\t%.10g\n", points[pp+0], points[pp+1], points[pp+2], points[pp+3], yaw, pch, rll);
}
if (pp >= 4*enn)
status=MIDDLE;
break;
case MIDDLE: /* middle points (at least one)*/
for (i=0; i<3*enn*4; i++) {
VMOVEN(points+(4*i), points+(4*(i+1)), 4);
}
num_read=scanf("%lf %lf %lf %lf", &scan[0], &scan[1], &scan[2], &scan[3]);
/* convert double to fastf_t */
HMOVE(points+(4*(3*enn)), scan);
if (num_read < 4) {
pp = 0;
status = WANE;
}
get_orientation(points, points+(4*enn), points+4*(2*enn), f_prm_1, &yaw, &pch, &rll);
if (!(count%print_int)&&!estimate_f) {
printf("%.10g\t%.10g\t%.10g\t%.10g\t%.10g\t%.10g\t%.10g\n", points[4*(enn)+0], points[4*(enn)+1], points[4*(enn)+2], points[4*(enn)+3], yaw, pch, rll);
}
break;
case WANE: /* last n - 1 middle points */
pp += 4;
if (pp >= 4*enn) {
status = END;
count--;
pp = 0;
break;
}
get_orientation(points+pp, points+pp+4*enn, points+pp+4*2*enn, f_prm_1, &yaw, &pch, &rll);
if (!(count%print_int)&&!estimate_f) {
printf("%.10g\t%.10g\t%.10g\t%.10g\t%.10g\t%.10g\t%.10g\n", points[4*(enn)+0+pp], points[4*(enn)+1+pp], points[4*(enn)+2+pp], points[4*(enn)+3+pp], yaw, pch, rll);
}
break;
case END: /* last n points */
get_orientation(points+pp, points+pp+4*enn, points+pp+4*2*enn, f_prm_2, &yaw, &pch, &rll);
if (!(count%print_int)&&!estimate_f) {
printf("%.10g\t%.10g\t%.10g\t%.10g\t%.10g\t%.10g\t%.10g\n", points[8*enn+pp+0], points[8*enn+pp+1], points[8*enn+pp+2], points[8*enn+pp+3], yaw, pch, rll);
}
pp += 4;
if (pp >= 4*enn)
status = STOP;
break;
}
count++;
}
/* Return the factor needed to achieve the requested max_bank */
if (estimate_f) {
if (max_cross < VDIVIDE_TOL) {
printf("%.10g\n", 0.0);
} else {
printf("%.10g\n", 1000.0 * max_bank/max_cross);
}
}
bu_free(points, "points");
return 0;
}
/*
* F _ N I R T
*
* Invoke nirt with the current view & stuff
*/
int
dgo_nirt_cmd(struct dg_obj *dgop,
struct view_obj *vop,
int argc,
const char **argv)
{
const char **vp;
FILE *fp_in;
FILE *fp_out, *fp_err;
#ifndef _WIN32
int ret;
size_t sret;
int pid, rpid;
int retcode;
int pipe_in[2];
int pipe_out[2];
int pipe_err[2];
#else
HANDLE pipe_in[2], pipe_inDup;
HANDLE pipe_out[2], pipe_outDup;
HANDLE pipe_err[2], pipe_errDup;
STARTUPINFO si;
PROCESS_INFORMATION pi;
SECURITY_ATTRIBUTES sa;
char name[1024];
char line1[2048];
int rem = 2048;
#endif
int use_input_orig = 0;
vect_t center_model;
vect_t dir;
vect_t cml;
int i;
struct solid *sp;
char line[RT_MAXLINE];
char *val;
struct bu_vls vls = BU_VLS_INIT_ZERO;
struct bu_vls o_vls = BU_VLS_INIT_ZERO;
struct bu_vls p_vls = BU_VLS_INIT_ZERO;
struct bu_vls t_vls = BU_VLS_INIT_ZERO;
struct bn_vlblock *vbp;
struct dg_qray_dataList *ndlp;
struct dg_qray_dataList HeadQRayData;
int args;
args = argc + 20 + 2 + dgo_count_tops((struct solid *)&dgop->dgo_headSolid);
dgop->dgo_rt_cmd = (char **)bu_calloc(args, sizeof(char *), "alloc dgo_rt_cmd");
vp = (const char **)&dgop->dgo_rt_cmd[0];
*vp++ = "nirt";
/* swipe x, y, z off the end if present */
if (argc > 3) {
double scan[3];
if (sscanf(argv[argc-3], "%lf", &scan[X]) == 1 &&
sscanf(argv[argc-2], "%lf", &scan[Y]) == 1 &&
sscanf(argv[argc-1], "%lf", &scan[Z]) == 1)
{
VMOVE(center_model, scan);
use_input_orig = 1;
argc -= 3;
VSCALE(center_model, center_model, dgop->dgo_wdbp->dbip->dbi_local2base);
}
}
/* Calculate point from which to fire ray */
if (!use_input_orig) {
VSET(center_model, -vop->vo_center[MDX],
-vop->vo_center[MDY], -vop->vo_center[MDZ]);
}
VSCALE(cml, center_model, dgop->dgo_wdbp->dbip->dbi_base2local);
VMOVEN(dir, vop->vo_rotation + 8, 3);
VSCALE(dir, dir, -1.0);
bu_vls_printf(&p_vls, "xyz %lf %lf %lf;",
cml[X], cml[Y], cml[Z]);
bu_vls_printf(&p_vls, "dir %lf %lf %lf; s",
dir[X], dir[Y], dir[Z]);
i = 0;
if (DG_QRAY_GRAPHICS(dgop)) {
*vp++ = "-e";
*vp++ = DG_QRAY_FORMAT_NULL;
/* first ray ---- returns partitions */
*vp++ = "-e";
*vp++ = DG_QRAY_FORMAT_P;
/* ray start, direction, and 's' command */
*vp++ = "-e";
*vp++ = bu_vls_addr(&p_vls);
/* second ray ---- returns overlaps */
*vp++ = "-e";
*vp++ = DG_QRAY_FORMAT_O;
/* ray start, direction, and 's' command */
*vp++ = "-e";
*vp++ = bu_vls_addr(&p_vls);
if (DG_QRAY_TEXT(dgop)) {
char *cp;
int count = 0;
/* get 'r' format now; prepend its' format string with a newline */
val = bu_vls_addr(&dgop->dgo_qray_fmts[0].fmt);
/* find first '"' */
while (*val != '"' && *val != '\0')
++val;
if (*val == '\0')
goto done;
else
++val; /* skip first '"' */
/* find last '"' */
cp = (char *)strrchr(val, '"');
if (cp != (char *)NULL) /* found it */
count = cp - val;
done:
if (*val == '\0')
bu_vls_printf(&o_vls, " fmt r \"\\n\" ");
else {
struct bu_vls tmp = BU_VLS_INIT_ZERO;
bu_vls_strncpy(&tmp, val, count);
bu_vls_printf(&o_vls, " fmt r \"\\n%V\" ", &tmp);
bu_vls_free(&tmp);
if (count)
val += count + 1;
bu_vls_printf(&o_vls, "%s", val);
}
i = 1;
*vp++ = "-e";
*vp++ = bu_vls_addr(&o_vls);
}
}
if (DG_QRAY_TEXT(dgop)) {
/* load vp with formats for printing */
for (; dgop->dgo_qray_fmts[i].type != (char)0; ++i)
bu_vls_printf(&t_vls, "fmt %c %s; ",
dgop->dgo_qray_fmts[i].type,
bu_vls_addr(&dgop->dgo_qray_fmts[i].fmt));
*vp++ = "-e";
*vp++ = bu_vls_addr(&t_vls);
/* nirt does not like the trailing ';' */
bu_vls_trunc(&t_vls, -2);
}
/* include nirt script string */
if (bu_vls_strlen(&dgop->dgo_qray_script)) {
*vp++ = "-e";
*vp++ = bu_vls_addr(&dgop->dgo_qray_script);
}
*vp++ = "-e";
*vp++ = bu_vls_addr(&p_vls);
for (i = 1; i < argc; i++)
*vp++ = argv[i];
*vp++ = dgop->dgo_wdbp->dbip->dbi_filename;
dgop->dgo_rt_cmd_len = (char **)vp - (char **)dgop->dgo_rt_cmd;
/* Note - dgo_build_tops sets the last vp to (char *)0 */
dgop->dgo_rt_cmd_len += dgo_build_tops((struct solid *)&dgop->dgo_headSolid,
vp,
(const char **)&dgop->dgo_rt_cmd[args]);
if (dgop->dgo_qray_cmd_echo) {
/* Print out the command we are about to run */
vp = (const char **)&dgop->dgo_rt_cmd[0];
while (*vp)
Tcl_AppendResult(dgop->interp, *vp++, " ", (char *)NULL);
Tcl_AppendResult(dgop->interp, "\n", (char *)NULL);
}
if (use_input_orig) {
bu_vls_printf(&vls, "\nFiring from (%lf, %lf, %lf)...\n",
center_model[X], center_model[Y], center_model[Z]);
Tcl_AppendResult(dgop->interp, bu_vls_addr(&vls), (char *)NULL);
bu_vls_free(&vls);
} else
Tcl_AppendResult(dgop->interp, "\nFiring from view center...\n", (char *)NULL);
#ifndef _WIN32
ret = pipe(pipe_in);
if (ret < 0)
perror("pipe");
ret = pipe(pipe_out);
if (ret < 0)
perror("pipe");
ret = pipe(pipe_err);
if (ret < 0)
perror("pipe");
(void)signal(SIGINT, SIG_IGN);
if ((pid = fork()) == 0) {
/* Redirect stdin, stdout, stderr */
(void)close(0);
ret = dup(pipe_in[0]);
if (ret < 0)
perror("dup");
(void)close(1);
ret = dup(pipe_out[1]);
if (ret < 0)
perror("dup");
(void)close(2);
ret = dup(pipe_err[1]);
if (ret < 0)
perror("dup");
/* close pipes */
(void)close(pipe_in[0]);
(void)close(pipe_in[1]);
(void)close(pipe_out[0]);
(void)close(pipe_out[1]);
(void)close(pipe_err[0]);
(void)close(pipe_err[1]);
for (i = 3; i < 20; i++)
(void)close(i);
(void)signal(SIGINT, SIG_DFL);
(void)execvp(dgop->dgo_rt_cmd[0], dgop->dgo_rt_cmd);
perror (dgop->dgo_rt_cmd[0]);
exit(16);
}
/* use fp_in to feed view info to nirt */
(void)close(pipe_in[0]);
fp_in = fdopen(pipe_in[1], "w");
/* use fp_out to read back the result */
(void)close(pipe_out[1]);
fp_out = fdopen(pipe_out[0], "r");
/* use fp_err to read any error messages */
(void)close(pipe_err[1]);
fp_err = fdopen(pipe_err[0], "r");
/* send quit command to nirt */
sret = fwrite("q\n", 1, 2, fp_in);
if (sret != 2)
bu_log("fwrite failure\n");
(void)fclose(fp_in);
#else
memset((void *)&si, 0, sizeof(STARTUPINFO));
memset((void *)&pi, 0, sizeof(PROCESS_INFORMATION));
memset((void *)&sa, 0, sizeof(SECURITY_ATTRIBUTES));
sa.nLength = sizeof(sa);
sa.bInheritHandle = TRUE;
sa.lpSecurityDescriptor = NULL;
/* Create a pipe for the child process's STDOUT. */
CreatePipe(&pipe_out[0], &pipe_out[1], &sa, 0);
/* Create noninheritable read handle and close the inheritable read handle. */
DuplicateHandle(GetCurrentProcess(), pipe_out[0],
GetCurrentProcess(), &pipe_outDup ,
0, FALSE,
DUPLICATE_SAME_ACCESS);
CloseHandle(pipe_out[0]);
/* Create a pipe for the child process's STDERR. */
CreatePipe(&pipe_err[0], &pipe_err[1], &sa, 0);
/* Create noninheritable read handle and close the inheritable read handle. */
DuplicateHandle(GetCurrentProcess(), pipe_err[0],
GetCurrentProcess(), &pipe_errDup ,
0, FALSE,
DUPLICATE_SAME_ACCESS);
CloseHandle(pipe_err[0]);
/* The steps for redirecting child process's STDIN:
* 1. Save current STDIN, to be restored later.
* 2. Create anonymous pipe to be STDIN for child process.
* 3. Set STDIN of the parent to be the read handle to the
* pipe, so it is inherited by the child process.
* 4. Create a noninheritable duplicate of the write handle,
* and close the inheritable write handle.
*/
/* Create a pipe for the child process's STDIN. */
CreatePipe(&pipe_in[0], &pipe_in[1], &sa, 0);
/* Duplicate the write handle to the pipe so it is not inherited. */
DuplicateHandle(GetCurrentProcess(), pipe_in[1],
GetCurrentProcess(), &pipe_inDup,
0, FALSE, /* not inherited */
DUPLICATE_SAME_ACCESS);
CloseHandle(pipe_in[1]);
si.cb = sizeof(STARTUPINFO);
si.lpReserved = NULL;
si.lpReserved2 = NULL;
si.cbReserved2 = 0;
si.lpDesktop = NULL;
si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
si.hStdInput = pipe_in[0];
si.hStdOutput = pipe_out[1];
si.hStdError = pipe_err[1];
si.wShowWindow = SW_HIDE;
snprintf(line1, rem, "%s ", dgop->dgo_rt_cmd[0]);
rem -= (int)strlen(line1) - 1;
for (i = 1; i < dgop->dgo_rt_cmd_len; i++) {
/* skip commands */
if (strstr(dgop->dgo_rt_cmd[i], "-e") != NULL)
++i;
else {
/* append other arguments (i.e. options, file and obj(s)) */
snprintf(name, 1024, "\"%s\" ", dgop->dgo_rt_cmd[i]);
if (rem - strlen(name) < 1) {
bu_log("Ran out of buffer space!");
bu_free(dgop->dgo_rt_cmd, "free dgo_rt_cmd");
dgop->dgo_rt_cmd = NULL;
return TCL_ERROR;
}
bu_strlcat(line1, name, sizeof(line1));
rem -= (int)strlen(name);
}
}
CreateProcess(NULL, line1, NULL, NULL, TRUE,
DETACHED_PROCESS, NULL, NULL,
&si, &pi);
/* use fp_in to feed view info to nirt */
CloseHandle(pipe_in[0]);
fp_in = _fdopen(_open_osfhandle((intptr_t)pipe_inDup, _O_TEXT), "wb");
setmode(fileno(fp_in), O_BINARY);
/* send commands down the pipe */
for (i = 1; i < dgop->dgo_rt_cmd_len-2; i++)
if (strstr(dgop->dgo_rt_cmd[i], "-e") != NULL)
fprintf(fp_in, "%s\n", dgop->dgo_rt_cmd[++i]);
/* use fp_out to read back the result */
CloseHandle(pipe_out[1]);
fp_out = _fdopen(_open_osfhandle((intptr_t)pipe_outDup, _O_TEXT), "rb");
setmode(fileno(fp_out), O_BINARY);
/* use fp_err to read any error messages */
CloseHandle(pipe_err[1]);
fp_err = _fdopen(_open_osfhandle((intptr_t)pipe_errDup, _O_TEXT), "rb");
setmode(fileno(fp_err), O_BINARY);
/* send quit command to nirt */
fwrite("q\n", 1, 2, fp_in);
(void)fclose(fp_in);
#endif
bu_vls_free(&p_vls); /* use to form "partition" part of nirt command above */
if (DG_QRAY_GRAPHICS(dgop)) {
double scan[4];
if (DG_QRAY_TEXT(dgop))
bu_vls_free(&o_vls); /* used to form "overlap" part of nirt command above */
BU_LIST_INIT(&HeadQRayData.l);
/* handle partitions */
while (bu_fgets(line, RT_MAXLINE, fp_out) != (char *)NULL) {
if (line[0] == '\n') {
Tcl_AppendResult(dgop->interp, line+1, (char *)NULL);
break;
}
BU_ALLOC(ndlp, struct dg_qray_dataList);
BU_LIST_APPEND(HeadQRayData.l.back, &ndlp->l);
if (sscanf(line, "%le %le %le %le",
&scan[0], &scan[1], &scan[2], &scan[3]) != 4)
break;
ndlp->x_in = scan[0];
ndlp->y_in = scan[1];
ndlp->z_in = scan[2];
ndlp->los = scan[3];
}
vbp = rt_vlblock_init();
dgo_qray_data_to_vlist(dgop, vbp, &HeadQRayData, dir, 0);
bu_list_free(&HeadQRayData.l);
dgo_cvt_vlblock_to_solids(dgop, vbp, bu_vls_addr(&dgop->dgo_qray_basename), 0);
rt_vlblock_free(vbp);
/* handle overlaps */
while (bu_fgets(line, RT_MAXLINE, fp_out) != (char *)NULL) {
if (line[0] == '\n') {
Tcl_AppendResult(dgop->interp, line+1, (char *)NULL);
break;
}
BU_ALLOC(ndlp, struct dg_qray_dataList);
BU_LIST_APPEND(HeadQRayData.l.back, &ndlp->l);
if (sscanf(line, "%le %le %le %le",
&scan[0], &scan[1], &scan[2], &scan[3]) != 4)
break;
ndlp->x_in = scan[0];
ndlp->y_in = scan[1];
ndlp->z_in = scan[2];
ndlp->los = scan[3];
}
vbp = rt_vlblock_init();
dgo_qray_data_to_vlist(dgop, vbp, &HeadQRayData, dir, 1);
bu_list_free(&HeadQRayData.l);
dgo_cvt_vlblock_to_solids(dgop, vbp, bu_vls_addr(&dgop->dgo_qray_basename), 0);
rt_vlblock_free(vbp);
}
/*
* Notify observers, if any, before generating textual output since
* such an act (observer notification) wipes out whatever gets stuffed
* into the result.
*/
dgo_notify(dgop);
if (DG_QRAY_TEXT(dgop)) {
bu_vls_free(&t_vls);
while (bu_fgets(line, RT_MAXLINE, fp_out) != (char *)NULL)
Tcl_AppendResult(dgop->interp, line, (char *)NULL);
}
(void)fclose(fp_out);
while (bu_fgets(line, RT_MAXLINE, fp_err) != (char *)NULL)
Tcl_AppendResult(dgop->interp, line, (char *)NULL);
(void)fclose(fp_err);
#ifndef _WIN32
/* Wait for program to finish */
while ((rpid = wait(&retcode)) != pid && rpid != -1)
; /* NULL */
if (retcode != 0)
pr_wait_status(dgop->interp, retcode);
#else
/* Wait for program to finish */
WaitForSingleObject(pi.hProcess, INFINITE);
#endif
FOR_ALL_SOLIDS(sp, &dgop->dgo_headSolid)
sp->s_wflag = DOWN;
bu_free(dgop->dgo_rt_cmd, "free dgo_rt_cmd");
dgop->dgo_rt_cmd = NULL;
return TCL_OK;
}
