/* * tools.h * $Id$ * headers and descriptions for ray tracing toolkit */ #ifndef TK_TOOLS_H #define TK_TOOLS_H #ifndef real #define real double #endif /* ------------------------------------------------------------------------ */ /* TK_result is opaque struct for building the result of * tracing a set of rays through a mesh. * result= ray_result(); * mallocs and initializes result * ray_store(result, cell, s, 1); * begins a new ray -- cell is unused, and s is the position * of the entry point for the new ray * ray_store(result, cell, s, 0); * appends ray intersection point exiting cell at s * a single result struct can hold many rays * ray_store(result, cell, s, 2); * signals that current ray is re-entering mesh at s * n= ray_collect(result, 0, 0); * return number of intersections stored in result so far * ray_collect(result, cell, s, origin); * copy intersection values into contiguous cell and s arrays * cell[] is an array of the form * [countA, cell1, cell2, cell3, ..., countB, cell1, cell2, ...] * where each count is the number of intersection points on a * contiguous section of the ray, and is followed by count-1 * cell index values; counts can be negative to indicate that * a single ray has re-entered the mesh * s[] is the corresponding array of positions along the ray * [s0, s1, s2, s3, ..., s0, s1, s2, ...] * ray_reset(result); * reset result to 0 intersections * ray_free(result); * free all memory associated with result, pointer becomes invalid * nrays= ray_reduce(len_cell, cell, 0, 0); * nlist= malloc(sizeof(long)*nrays); * nrays= ray_reduce(len_cell, cell, s, nlist, slims); * compress the cell and s arrays returning nrays and nlist[nrays], * taking successive differences of s and moving the counts from * cell to nlist * if slims non-0, must be slims[nrays][2] [smin,smax] for each ray * ray_integ(nrays, nlist, ngroup, transp, selfem, result) * perform sums and products of transp and selfem * if ngroup<0, group index is final index in transp, selfem */ typedef struct TK_result TK_result; extern TK_result *ray_result(void); extern void ray_store(TK_result *result, long cell, real s, int first); extern long ray_collect(TK_result *result, long *cell, real *s, long orig); extern void ray_reset(TK_result *result); extern void ray_free(TK_result *result); extern long ray_reduce(long len, long *cell, real *s, long *nlist, real slims[][2]); extern void ray_integ(long nr, long *nlist, long ng, real *transp, real *selfem, real *result); /* ------------------------------------------------------------------------ */ typedef struct TK_ray TK_ray; struct TK_ray { /* describe the ray in space, used to partially project mesh coordinates * * p a point on the ray * qr reciprocal ray direction [q0/q2,q1/q2,1/q2] * order permutation of mesh axes required to make q2 largest * component of q in absolute value * that is, order[0] is the index in mesh coordinates * corresponding to index 0 in p, qr, or qp, order[1] * in the mesh corresponds to p[1], and order[2] to p[2] */ real p[3], qr[3]; int order[3]; /* describe reflection history of ray * * q normalized ray direction, in non-permuted (mesh) order * qp vector perpendicular to ray, in permuted order * -- this is the normal to the boundary plane during * the entry search (unnormalized) * odd 1 if odd number of reflections, 0 if even number * -- qp, odd valid only during entry search */ real q[3], qp[3]; int odd; }; /* ------------------------------------------------------------------------ */ extern int tet_traverse(real xy[][3], int tet[]); /* * tetrahedron traversal machinery for straight rays * Parameters: * xy[][3] (input) scratch array containing corner coordinates * tet[4] (in/out) indices of tet coordinates in xy * Assumptions: * ray enters triangle (tet[0],tet[1],tet[2]), whose area is * non-zero, and area element is positive in projected coordinates * Output: * tet[3] swapped with tet[return value], such that the two * above assumptions ray_reflect (tet[0],tet[1],tet[2]) on output * for the exit face from the tet * Notes: * if ray hits an edge or the apex point tet[3], choose the * triangle with largest area as the exit (makes loops impossible) * xy[i][2] are unused */ extern real tri_intersect(real xy[][3], int tri[]); /* * z= tri_intersect(tri, xy) finds intersection of ray with triangle * Parameters: * xy[][3] (input) are the xyz coordinates of the triangle * tri[3] (input) are the indices into xy (assumed a small working array) * of the triangle; the 2D area of tri[0:2] is non-zero * Return value: * return value is z value where (x,y) equals (0,0) */ /* ------------------------------------------------------------------------ */ extern int tri_traverse(real qp[], real xy[][3], int tri[], real dot[]); /* * triangle traversing machinery for ray entry search * discard= tri_traverse(qp, xy, tri, dot) * Parameters: * qp[2] (input) normal to plane on which to search for entry * xy[][3] (input) scratch array containing corner coordinates * tri[3] (in/out) indices of triangle coordinates in xy * dot[2] (in/out) dot[0]>=0. and dot[1]<=0. are dot products * of plane with tri[0:1] corners, dot[] is * updated here(see below) * Assumptions: * at least one of dot[0:1] is non-zero * routine guarantees dot[0]>=0. and dot[1]<=0. with at least * one non-zero on output as well * Output: * tri[2] swapped with tri[return value], such that the two * above assumptions ray_reflect (tri[0],tri[1]) on output * for the exit edge from the triangle * dot for tri[2] is computed, then becomes dot[return value] * Notes: * if dot computes to zero, tri swaps with smaller of ABS(dot[0:1]) * xy[i][2] are unused */ extern int tri_contains(real xy[][3], int tri[]); /* * test whether triangle contains (0,0) * Parameters: * xy[][3] (input) scratch array containing corner coordinates * tri[3] (input) indices of tri coordinates in xy * Assumptions: * triangle area is non-negative * Output: * returns 1 if (0,0) interior to tri, else 0 * always returns 0 if area is 0 * Notes: * xy[i][2] are unused */ extern void tri_check(real xy[][3], int tri[]); /* * test whether triangle area is non-negative, swap tri[0] and tri[1] * so on output area is always non-negative * Parameters: * xy[][3] (input) scratch array containing corner coordinates * tri[3] (in/out) indices of tri coordinates in xy * Notes: * xy[i][2] are unused */ extern int edge_test(real xy[][3], int tri[], real dot[], int flags[]); /* * test whether entry point has been found * hit_miss= edge_test(xy, tri, dot, flags) * Parameters: * xy[][3] (input) partially projected coordinates * tri[2] (input) indices of test edge in xy * dot[4] (in/out) dot[0]>=0, dot[1]<=0 are dot products of tri[0:1] * with normal to entry plane (input only) * dot[2] is previous "x" value, which is updated * to "x" on this edge by tri_test * dot[3] is typical scale length for changes in xy * flags[3] (in/out) flags[0] = index of "x" direction in xy (0 or 1) * flags[1] = 1 if dx<0 means we're on the entry * side of the boundary (where the ray can enter) * flags[2] = 1 if we've ever been on entry side * flags[0:1] are input only, flags[2] updated * Return value: * 0 means the entry search should continue * 1 means the ray hit the boundary between previous edge and this edge * 2 means the ray misses the boundary */ extern int entry_setup(TK_ray *ray, real xy[][3], int tri[], real dot[], int flags[]); /* * set up for entry point search * discard= entry_setup(ray, xy, tri, dot, flags) * Parameters: * ray (in/out) qp is output * xy[][3] (input) partially projected coordinates * tri[3] (in/out) indices of boundary triangle in xy * on entry, these are ordered so that triangle 012 * surface element points toward mesh interior * on exit, they have been permuted to look as if * tri_traverse had just been called * dot[4] (output) dot[0]>=0, dot[1]<=0 are dot products of tri[0:1] * with normal to entry plane -- as by tri_traverse * dot[2] is previous "x" value -- as by edge_test * dot[3] is typical scale length for changes in xy * flags[3] (output) flags[0] = index of "x" direction in xy (0 or 1) * flags[1] = 1 if dx<0 means we're on the entry * side of the boundary (where the ray can enter) * flags[2] = 1 if initial triangle on entry side * Return value: * 0 or 1 depending on whether output tri[0] or tri[1] swapped * with tri[2], as for tri_traverse * 2 if ray lies in plane of boundary triangle * Actions: * (1) Select a point inside the initial triangle but not on the ray, * set ray->qp to be normal to the entry plane so determined. * (2) Set the "x" direction (flags[0]) as the one least parallel to qp. * (3) Compute dot product of all three points with qp to determine * which side of the entry plane each is on. Two are always on * one side and one on the other. * (4) Compute the two intersections of the entry plane with the initial * triangle, and also to which side of this line in the entry plane * the mesh lies. * (5) Select a direction for the entry search: Always toward the ray if * initial triangle is on entry side of boundary, either toward or * away from q[2] if on the exit side, depending on the value of * the external variable interior_boundary. * (6) Load dot, flags, and tri as required. May need to change sign of * qp in order to make dot[0]>0, dot[1]<0. On exit, 012 is an odd * permutation of the order on entry, as after tri_traverse. */ extern int interior_boundary; /* ------------------------------------------------------------------------ */ extern int ray_reflect(TK_ray *ray, real xy[][3], int tri[], real dot[], int flags[]); /* * ray_reflect(ray, xy, tri, dot, flags) * Parameters: * ray (in/out) the ray to reflect * xy[][3] (input) partially projected coordinates * *not updated* even though changes in ray change xy * tri[3] (input) indices into xy of triangle in reflection plane * dot[3] (in/out) dot[2] is updated if flags!=0 (dot[0:1] correct) * flags[3] (in/out) flags==0 skips entry calculation, if non-zero: * ray->qp is updated * dot[2] and flags[0:2] updated * entry updates presume that tri[0:1] is boundary * edge, while tri[2] is inside mesh (not on boundary) * Return value: * 0 input tri handedness unchanged * 1 input tri changed handedness */ /* ------------------------------------------------------------------------ */ extern void ray_init(TK_ray *ray, real p[], real q[], real matrix[][3]); /* * ray_init(ray, p, q, matrix) * Parameters: * ray (output) the ray to initialize * p[3] (input) point on the ray * q[3] (input) normalized ray direction * matrix[5][3] (input) transformation matrix to apply to p, q * matrix[3] is offset applied to p only * matrix==0 means no tranform * matrix[4] is * point on previous ray in mesh coordinates * corresponding to matrix[3] (only if matrix!=0) * Action: * ray->qp is zeroed, the rest initialized properly */ extern int update_transform(TK_ray *ray, real p0[], real q0[], real matrix[][3], int odd); /* * odd= update_transform(ray, p0, q0, matrix, odd) * Parameters: * ray (output) the ray after entry search * p0[3] (input) point on the ray in mesh coordinates * q0[3] (input) normalized ray direction in mesh coordinates * matrix[5][3] (in/out) transformation matrix to apply to p, q * matrix[3] is offset applied to p only on output * on input, must be qp0 vector after entry_setup * but before any calls to reflect_ray * matrix[4] is set to input p0 * odd (input) non-zero if matrix is a reflection * Return value: * odd for output matrix * Action: * First applies inverse (transpose) matrix to matrix[3] to find * qp0 in mesh coordinates. * Next, computes new matrix[0:2] as the tranform that takes mesh * coordinates to multiply reflected coordinates. * Finally, stores ray->p in matrix[3]. */ /* ------------------------------------------------------------------------ */ #endif

Generated by Doxygen 1.6.0 Back to index