// Calculates the position at point t along the spline with co-efficients
// A, B, C and D.
// spline(t) = ((A * t + B) * t + C) * t + D
void ribbon_spline(float *pos, const float * const A, const float * const B,
const float * const C, const float * const D, const float t) {
vec_copy(pos,D);
vec_scaled_add(pos,t,C);
vec_scaled_add(pos,t*t,B);
vec_scaled_add(pos,t*t*t,A);
}
void get_transform_to_orthonormal_cell(const float *cell, const float *center, Matrix4 &transform) {
// Orthogonalize system:
// Find an orthonormal basis of the cell (in cartesian coords).
// If the cell vectors from VMD/NAMD are used this should actually always
// return the identity matrix due to the way the cell vectors A, B and C
// are defined (i.e. A || x; B lies in the x,y-plane; A, B, C form a right
// hand system).
float obase[3*3];
orthonormal_basis(cell, obase);
// Get orthonormal base in cartesian coordinates (it is the inverse of the
// obase->cartesian transformation):
float identity[3*3] = {1, 0, 0, 0, 1, 0, 0, 0, 1};
float obase_cartcoor[3*3];
basis_change(obase, identity, obase_cartcoor, 3);
// Transform 3x3 into 4x4 matrix:
Matrix4 obase2cartinv;
trans_from_rotate(obase_cartcoor, &obase2cartinv);
// This is the matrix for the obase->cartesian transformation:
Matrix4 obase2cart = obase2cartinv;
obase2cart.inverse();
// Get coordinates of cell in terms of obase
float m[3*3];
basis_change(cell, obase, m, 3);
Matrix4 rotmat;
trans_from_rotate(m, &rotmat);
rotmat.inverse();
// Actually we have:
// transform = translation * obase2cart * obase2cartinv * rotmat * obase2cart
// `------------v------------'
// = 1
transform = obase2cart;
transform.multmatrix(rotmat); // pre-multiplication
// Finally we need to apply the translation of the origin
float origin[3];
vec_copy(origin, center);
vec_scaled_add(origin, -0.5, &cell[0]);
vec_scaled_add(origin, -0.5, &cell[3]);
vec_scaled_add(origin, -0.5, &cell[6]);
vec_negate(origin, origin);
//printf("origin={%g %g %g}\n", origin[0], origin[1], origin[2]);
transform.translate(origin);
}
// Computes the rectangular bounding box for the PBC cell.
// If the molecule was rotated/moved you can supply the transformation
// matrix and you'll get the bounding box of the transformed cell.
int compute_pbcminmax(MoleculeList *mlist, int molid, int frame,
const float *center, const Matrix4 *transform,
float *min, float *max) {
Molecule *mol = mlist->mol_from_id(molid);
if( !mol )
return MEASURE_ERR_NOMOLECULE;
Timestep *ts = mol->get_frame(frame);
if (!ts) return MEASURE_ERR_NOFRAMES;
// Get the displacement vectors (in form of translation matrices)
Matrix4 Tpbc[3];
ts->get_transforms(Tpbc[0], Tpbc[1], Tpbc[2]);
// Construct the cell spanning vectors
float cell[9];
cell[0] = Tpbc[0].mat[12];
cell[1] = Tpbc[0].mat[13];
cell[2] = Tpbc[0].mat[14];
cell[3] = Tpbc[1].mat[12];
cell[4] = Tpbc[1].mat[13];
cell[5] = Tpbc[1].mat[14];
cell[6] = Tpbc[2].mat[12];
cell[7] = Tpbc[2].mat[13];
cell[8] = Tpbc[2].mat[14];
float len[3];
len[0] = sqrtf(dot_prod(&cell[0], &cell[0]));
len[1] = sqrtf(dot_prod(&cell[3], &cell[3]));
len[2] = sqrtf(dot_prod(&cell[6], &cell[6]));
// Construct all 8 corners (nodes) of the bounding box
float node[8*3];
int n=0;
float i, j, k;
for (i=-0.5; i<1.f; i+=1.f) {
for (j=-0.5; j<1.f; j+=1.f) {
for (k=-0.5; k<1.f; k+=1.f) {
// Apply the translation of the origin
vec_copy(node+3*n, center);
vec_scaled_add(node+3*n, i, &cell[0]);
vec_scaled_add(node+3*n, j, &cell[3]);
vec_scaled_add(node+3*n, k, &cell[6]);
// Apply global alignment transformation
transform->multpoint3d(node+3*n, node+3*n);
n++;
}
}
}
// Find minmax coordinates of all corners
for (n=0; n<8; n++) {
if (!n || node[3*n ]<min[0]) min[0] = node[3*n];
if (!n || node[3*n+1]<min[1]) min[1] = node[3*n+1];
if (!n || node[3*n+2]<min[2]) min[2] = node[3*n+2];
if (!n || node[3*n ]>max[0]) max[0] = node[3*n];
if (!n || node[3*n+1]>max[1]) max[1] = node[3*n+1];
if (!n || node[3*n+2]>max[2]) max[2] = node[3*n+2];
}
return MEASURE_NOERR;
}
int measure_pbc_neighbors(MoleculeList *mlist, AtomSel *sel, int molid,
int frame, const Matrix4 *alignment,
const float *center, const float *cutoff, const float *box,
ResizeArray<float> *extcoord_array,
ResizeArray<int> *indexmap_array) {
int orig_ts, max_ts;
if (!box && !cutoff[0] && !cutoff[1] && !cutoff[2]) return MEASURE_NOERR;
Molecule *mol = mlist->mol_from_id(molid);
if( !mol )
return MEASURE_ERR_NOMOLECULE;
// get current frame number and make sure there are frames
if((orig_ts = mol->frame()) < 0)
return MEASURE_ERR_NOFRAMES;
// get the max frame number and determine current frame
max_ts = mol->numframes()-1;
if (frame==-2) frame = orig_ts;
else if (frame>max_ts || frame==-1) frame = max_ts;
Timestep *ts = mol->get_frame(frame);
if (!ts) return MEASURE_ERR_NOMOLECULE;
// Get the displacement vectors (in form of translation matrices)
Matrix4 Tpbc[3][2];
ts->get_transforms(Tpbc[0][1], Tpbc[1][1], Tpbc[2][1]);
// Assign the negative cell translation vectors
Tpbc[0][0] = Tpbc[0][1];
Tpbc[1][0] = Tpbc[1][1];
Tpbc[2][0] = Tpbc[2][1];
Tpbc[0][0].inverse();
Tpbc[1][0].inverse();
Tpbc[2][0].inverse();
// Construct the cell spanning vectors
float cell[9];
cell[0] = Tpbc[0][1].mat[12];
cell[1] = Tpbc[0][1].mat[13];
cell[2] = Tpbc[0][1].mat[14];
cell[3] = Tpbc[1][1].mat[12];
cell[4] = Tpbc[1][1].mat[13];
cell[5] = Tpbc[1][1].mat[14];
cell[6] = Tpbc[2][1].mat[12];
cell[7] = Tpbc[2][1].mat[13];
cell[8] = Tpbc[2][1].mat[14];
float len[3];
len[0] = sqrtf(dot_prod(&cell[0], &cell[0]));
len[1] = sqrtf(dot_prod(&cell[3], &cell[3]));
len[2] = sqrtf(dot_prod(&cell[6], &cell[6]));
//printf("len={%.3f %.3f %.3f}\n", len[0], len[1], len[2]);
int i;
float minlen = len[0];
if (len[1] && len[1]<minlen) minlen = len[1];
if (len[2] && len[2]<minlen) minlen = len[2];
minlen--;
// The algorithm works only for atoms in adjacent neighbor cells.
if (!box && (cutoff[0]>=len[0] || cutoff[1]>=len[1] || cutoff[2]>=len[2])) {
return MEASURE_ERR_BADCUTOFF;
}
bool bigrim = 1;
float corecell[9];
float diag[3];
float origin[3];
memset(origin, 0, 3*sizeof(float));
Matrix4 M_norm;
if (box) {
// Get the matrix M_norm that transforms all atoms inside the
// unit cell into the normalized unitcell spanned by
// {1/len[0] 0 0} {0 1/len[1] 0} {0 0 1/len[2]}.
bigrim = 1;
float vtmp[3];
vec_add(vtmp, &cell[0], &cell[3]);
vec_add(diag, &cell[6], vtmp);
//printf("diag={%.3f %.3f %.3f}\n", diag[0], diag[1], diag[2]);
// Finally we need to apply the translation of the cell origin
vec_copy(origin, center);
vec_scaled_add(origin, -0.5, &cell[0]);
vec_scaled_add(origin, -0.5, &cell[3]);
vec_scaled_add(origin, -0.5, &cell[6]);
vec_negate(origin, origin);
//printf("origin={%.3f %.3f %.3f}\n", origin[0], origin[1], origin[2]);
} else if (2.0f*cutoff[0]<minlen && 2.0f*cutoff[1]<minlen && 2.0f*cutoff[2]<minlen) {
// The cutoff must not be larger than half of the smallest cell dimension
// otherwise we would have to use a less efficient algorithm.
// Get the matrix M_norm that transforms all atoms inside the
// corecell into the orthonormal unitcell spanned by {1 0 0} {0 1 0} {0 0 1}.
// The corecell ist the pbc cell minus cutoffs for each dimension.
vec_scale(&corecell[0], (len[0]-cutoff[0])/len[0], &cell[0]);
vec_scale(&corecell[3], (len[1]-cutoff[1])/len[1], &cell[3]);
vec_scale(&corecell[6], (len[2]-cutoff[2])/len[2], &cell[6]);
get_transform_to_orthonormal_cell(corecell, center, M_norm);
//printf("Using algorithm for small PBC environment.\n");
} else {
// Get the matrix M_norm that transforms all atoms inside the
// unit cell into the orthonormal unitcell spanned by {1 0 0} {0 1 0} {0 0 1}.
get_transform_to_orthonormal_cell(cell, center, M_norm);
bigrim = 1;
//printf("Using algorithm for large PBC environment.\n");
}
// In case the molecule was aligned our pbc cell is rotated and shifted.
// In order to transform a point P into the orthonormal cell (P') it
// first has to be unaligned (the inverse of the alignment):
// P' = M_norm * (alignment^-1) * P
Matrix4 alignmentinv(*alignment);
alignmentinv.inverse();
Matrix4 M_coretransform(M_norm);
M_coretransform.multmatrix(alignmentinv);
//printf("alignment = \n");
//print_Matrix4(alignment);
// Similarly if we want to transform a point P into its image P' we
// first have to unalign it, then apply the PBC translation and
// finally realign:
// P' = alignment * Tpbc * (alignment^-1) * P
// `-------------v--------------'
// transform
int j, u;
Matrix4 Tpbc_aligned[3][2];
if (!box) {
for (i=0; i<3; i++) {
for (j=0; j<2; j++) {
Tpbc_aligned[i][j].loadmatrix(*alignment);
Tpbc_aligned[i][j].multmatrix(Tpbc[i][j]);
Tpbc_aligned[i][j].multmatrix(alignmentinv);
}
}
}
Matrix4 M[3];
float *coords = ts->pos;
float *coor;
float orthcoor[3], wrapcoor[3];
//printf("cutoff={%.3f %.3f %.3f}\n", cutoff[0], cutoff[1], cutoff[2]);
if (box) {
float min_coord[3], max_coord[3];
// Increase box by cutoff
vec_sub(min_coord, box, cutoff);
vec_add(max_coord, box+3, cutoff);
//printf("Wrapping atoms into rectangular bounding box.\n");
//printf("min_coord={%.3f %.3f %.3f}\n", min_coord[0], min_coord[1], min_coord[2]);
//printf("max_coord={%.3f %.3f %.3f}\n", max_coord[0], max_coord[1], max_coord[2]);
vec_add(min_coord, min_coord, origin);
vec_add(max_coord, max_coord, origin);
float testcoor[9];
int idx, k;
// Loop over all atoms
for (idx=0; idx<ts->num; idx++) {
coor = coords+3*idx;
// Apply the inverse alignment transformation
// to the current test point.
M_coretransform.multpoint3d(coor, orthcoor);
// Loop over all 26 neighbor cells
// x
for (i=-1; i<=1; i++) {
// Choose the direction of translation
if (i>0) M[0].loadmatrix(Tpbc[0][1]);
else if (i<0) M[0].loadmatrix(Tpbc[0][0]);
else M[0].identity();
// Translate the unaligned atom
M[0].multpoint3d(orthcoor, testcoor);
// y
for (j=-1; j<=1; j++) {
// Choose the direction of translation
if (j>0) M[1].loadmatrix(Tpbc[1][1]);
else if (j<0) M[1].loadmatrix(Tpbc[1][0]);
else M[1].identity();
// Translate the unaligned atom
M[1].multpoint3d(testcoor, testcoor+3);
// z
for (k=-1; k<=1; k++) {
if(i==0 && j==0 && k==0) continue;
// Choose the direction of translation
if (k>0) M[2].loadmatrix(Tpbc[2][1]);
else if (k<0) M[2].loadmatrix(Tpbc[2][0]);
else M[2].identity();
// Translate the unaligned atom
M[2].multpoint3d(testcoor+3, testcoor+6);
// Realign atom
alignment->multpoint3d(testcoor+6, wrapcoor);
vec_add(testcoor+6, wrapcoor, origin);
if (testcoor[6]<min_coord[0] || testcoor[6]>max_coord[0]) continue;
if (testcoor[7]<min_coord[1] || testcoor[7]>max_coord[1]) continue;
if (testcoor[8]<min_coord[2] || testcoor[8]>max_coord[2]) continue;
// Atom is inside cutoff, add it to the list
for (int n=0; n<3; n++) extcoord_array->append(wrapcoor[n]);
indexmap_array->append(idx);
}
}
}
}
} else if (bigrim) {
// This is the more general but slower algorithm.
// We loop over all atoms, move each atom to all 26 neighbor cells
// and check if it lies inside cutoff
float min_coord[3], max_coord[3];
min_coord[0] = -cutoff[0]/len[0];
min_coord[1] = -cutoff[1]/len[1];
min_coord[2] = -cutoff[2]/len[2];
max_coord[0] = 1.0f + cutoff[0]/len[0];
max_coord[1] = 1.0f + cutoff[1]/len[1];
max_coord[2] = 1.0f + cutoff[2]/len[2];
float testcoor[3];
int idx, k;
// Loop over all atoms
for (idx=0; idx<ts->num; idx++) {
coor = coords+3*idx;
// Apply the PBC --> orthonormal unitcell transformation
// to the current test point.
M_coretransform.multpoint3d(coor, orthcoor);
// Loop over all 26 neighbor cells
// x
for (i=-1; i<=1; i++) {
testcoor[0] = orthcoor[0]+(float)(i);
if (testcoor[0]<min_coord[0] || testcoor[0]>max_coord[0]) continue;
// Choose the direction of translation
if (i>0) M[0].loadmatrix(Tpbc_aligned[0][1]);
else if (i<0) M[0].loadmatrix(Tpbc_aligned[0][0]);
else M[0].identity();
// y
for (j=-1; j<=1; j++) {
testcoor[1] = orthcoor[1]+(float)(j);
if (testcoor[1]<min_coord[1] || testcoor[1]>max_coord[1]) continue;
// Choose the direction of translation
if (j>0) M[1].loadmatrix(Tpbc_aligned[1][1]);
else if (j<0) M[1].loadmatrix(Tpbc_aligned[1][0]);
else M[1].identity();
// z
for (k=-1; k<=1; k++) {
testcoor[2] = orthcoor[2]+(float)(k);
if (testcoor[2]<min_coord[2] || testcoor[2]>max_coord[2]) continue;
if(i==0 && j==0 && k==0) continue;
// Choose the direction of translation
if (k>0) M[2].loadmatrix(Tpbc_aligned[2][1]);
else if (k<0) M[2].loadmatrix(Tpbc_aligned[2][0]);
else M[2].identity();
M[0].multpoint3d(coor, wrapcoor);
M[1].multpoint3d(wrapcoor, wrapcoor);
M[2].multpoint3d(wrapcoor, wrapcoor);
// Atom is inside cutoff, add it to the list
for (int n=0; n<3; n++) extcoord_array->append(wrapcoor[n]);
indexmap_array->append(idx);
}
}
}
}
} else {
Matrix4 Mtmp;
for (i=0; i < ts->num; i++) {
// Apply the PBC --> orthonormal unitcell transformation
// to the current test point.
M_coretransform.multpoint3d(coords+3*i, orthcoor);
// Determine in which cell we are.
int cellindex[3];
if (orthcoor[0]<0) cellindex[0] = -1;
else if (orthcoor[0]>1) cellindex[0] = 1;
else cellindex[0] = 0;
if (orthcoor[1]<0) cellindex[1] = -1;
else if (orthcoor[1]>1) cellindex[1] = 1;
else cellindex[1] = 0;
if (orthcoor[2]<0) cellindex[2] = -1;
else if (orthcoor[2]>1) cellindex[2] = 1;
else cellindex[2] = 0;
// All zero means we're inside the core --> no image.
if (!cellindex[0] && !cellindex[1] && !cellindex[2]) continue;
// Choose the direction of translation
if (orthcoor[0]<0) M[0].loadmatrix(Tpbc_aligned[0][1]);
else if (orthcoor[0]>1) M[0].loadmatrix(Tpbc_aligned[0][0]);
if (orthcoor[1]<0) M[1].loadmatrix(Tpbc_aligned[1][1]);
else if (orthcoor[1]>1) M[1].loadmatrix(Tpbc_aligned[1][0]);
if (orthcoor[2]<0) M[2].loadmatrix(Tpbc_aligned[2][1]);
else if (orthcoor[2]>1) M[2].loadmatrix(Tpbc_aligned[2][0]);
// Create wrapped copies of the atom:
// x, y, z planes
coor = coords+3*i;
for (u=0; u<3; u++) {
if (cellindex[u] && cutoff[u]) {
M[u].multpoint3d(coor, wrapcoor);
for (j=0; j<3; j++) extcoord_array->append(wrapcoor[j]);
indexmap_array->append(i);
}
}
Mtmp = M[0];
// xy edge
if (cellindex[0] && cellindex[1] && cutoff[0] && cutoff[1]) {
M[0].multmatrix(M[1]);
M[0].multpoint3d(coor, wrapcoor);
for (j=0; j<3; j++) extcoord_array->append(wrapcoor[j]);
indexmap_array->append(i);
}
// yz edge
if (cellindex[1] && cellindex[2] && cutoff[1] && cutoff[2]) {
M[1].multmatrix(M[2]);
M[1].multpoint3d(coor, wrapcoor);
for (j=0; j<3; j++) extcoord_array->append(wrapcoor[j]);
indexmap_array->append(i);
}
// zx edge
if (cellindex[0] && cellindex[2] && cutoff[0] && cutoff[2]) {
M[2].multmatrix(Mtmp);
M[2].multpoint3d(coor, wrapcoor);
for (j=0; j<3; j++) extcoord_array->append(wrapcoor[j]);
indexmap_array->append(i);
}
// xyz corner
if (cellindex[0] && cellindex[1] && cellindex[2]) {
M[1].multmatrix(Mtmp);
M[1].multpoint3d(coor, wrapcoor);
for (j=0; j<3; j++) extcoord_array->append(wrapcoor[j]);
indexmap_array->append(i);
}
}
} // endif
// If a selection was provided we select extcoords
// within cutoff of the original selection:
if (sel) {
int numext = sel->selected+indexmap_array->num();
float *extcoords = new float[3*numext];
int *indexmap = new int[numext];
int *others = new int[numext];
memset(others, 0, numext);
// Use the largest given cutoff
float maxcutoff = cutoff[0];
for (i=1; i<3; i++) {
if (cutoff[i]>maxcutoff) maxcutoff = cutoff[i];
}
// Prepare C-array of coordinates for find_within()
j=0;
for (i=0; i < sel->num_atoms; i++) {
if (!sel->on[i]) continue; //atom is not selected
extcoords[3*j] = coords[3*i];
extcoords[3*j+1] = coords[3*i+1];
extcoords[3*j+2] = coords[3*i+2];
indexmap[j] = i;
others[j++] = 1;
}
for (i=0; i<indexmap_array->num(); i++) {
extcoords[3*j] = (*extcoord_array)[3*i];
extcoords[3*j+1] = (*extcoord_array)[3*i+1];
extcoords[3*j+2] = (*extcoord_array)[3*i+2];
indexmap[j] = (*indexmap_array)[i];
others[j++] = 0;
}
// Initialize flags array to true, find_within() results are AND'd/OR'd in.
int *flgs = new int[numext];
for (i=0; i<numext; i++) {
flgs[i] = 1;
}
// Find coordinates from extcoords that are within cutoff of the ones
// with flagged in 'others' and set the flgs accordingly:
find_within(extcoords, flgs, others, numext, maxcutoff);
extcoord_array->clear();
indexmap_array->clear();
for (i=sel->selected; i<numext; i++) {
if (!flgs[i]) continue;
extcoord_array->append(extcoords[3*i]);
extcoord_array->append(extcoords[3*i+1]);
extcoord_array->append(extcoords[3*i+2]);
indexmap_array->append(indexmap[i]);
}
}
return MEASURE_NOERR;
}
// draw a 3-D field lines that follow the volume gradient
void
DrawMolItem::draw_volume_field_lines (int volid, float seedval, float minlen,
float maxlen, float thickness)
{
const VolumetricData * v = NULL;
v = mol->get_volume_data (volid);
int printdonemesg = 0;
if (v == NULL)
{
msgInfo << "No volume data loaded at index " << volid << sendmsg;
return;
}
int seedcount = 0;
int pointcount = 0;
int totalpointcount = 0;
int usecolor;
ResizeArray<float> seeds;
append (DMATERIALOFF);
usecolor = draw_volume_get_colorid ();
cmdColorIndex.putdata (usecolor, cmdList);
seedcount = calcseeds_gradient_magnitude (v, &seeds, seedval * 0.5f,
seedval * 1.5f);
// Integrate field lines starting with each of the seeds to simulate
// particle advection.
// Uses Euler's approximation for solving the initial value problem.
// We could get a more accurate solution using a fourth order Runge-Kutta
// method, but with more math per iteration. We may want to implement
// the integrator as a user selected option.
// The choice of integration step size is currently arbitrary,
// but will become a user-defined parameter, since it affects speed
// and accuracy. A good default might be 0.25 times the smallest
// grid cell spacing axis.
float lx, ly, lz;
v->cell_lengths (&lx, &ly, &lz);
float mincelllen = lx;
mincelllen = (mincelllen < ly) ? mincelllen : ly;
mincelllen = (mincelllen < lz) ? mincelllen : lz;
float delta = mincelllen * 0.25f; // delta per step (compensates gradient magnitude)
// minimum gradient magnitude, before we consider that we've found
// a critical point in the dataset.
float mingmag = 0.0001f;
// max gradient magnitude, before we consider it a source/sink
float maxgmag = 5;
ResizeArray<float> points;
// For each seed point, integrate in both positive and
// negative directions for a field line length up to
// the maxlen criterion.
msgtimer *msgt = msg_timer_create (1);
int seed;
for (seed = 0; seed < seedcount; seed++)
{
// emit UI messages as integrator runs, for long calculations...
if (!(seed & 7) && msg_timer_timeout (msgt))
{
char tmpbuf[128];
sprintf (tmpbuf, "%6.2f %% complete",
(100.0f * seed) / (float) seedcount);
msgInfo << "integrating " << seedcount << " field lines: " << tmpbuf
<< sendmsg;
printdonemesg = 1;
}
int direction;
for (direction = -1; direction != 1; direction = 1)
{
float pos[3], comsum[3];
vec_copy (pos, &seeds[seed * 3]); // integration starting point is the seed
// init the arrays
points.clear ();
// main integration loop
pointcount = 0;
totalpointcount++;
float len = 0;
int iterations = 0;
float dir = (float) direction;
vec_zero (comsum); // clear center of mass accumulator
while ((len < maxlen) && (totalpointcount < 100000000))
{
float grad[3];
// sample gradient at the current position
v->voxel_gradient_interpolate_from_coord (pos, grad);
// Early-exit if we run out of bounds (gradient returned will
// be a vector of NANs), run into a critical point (zero gradient)
// or a huge gradient at a source/sink point in the dataset.
float gmag = norm (grad);
if (gmag < mingmag || gmag > maxgmag)
break;
// Draw the current point only after the gradient value
// has been checked, so we don't end up with out-of-bounds
// vertices.
// Only emit a fraction of integration points for display since
// the integrator stepsize needs to be small for more numerical
// accuracy, but the field lines themselves can be well
// represented with fewer sample points.
if (!(iterations & 1))
{
// Add a vertex for this field line
points.append (pos[0]);
points.append (pos[1]);
points.append (pos[2]);
vec_incr (comsum, pos);
pointcount++;
totalpointcount++;
}
// adjust integration stepsize so we never move more than
// the distance specified by delta at each step, to compensate
// for varying gradient magnitude
vec_scaled_add (pos, dir * delta / gmag, grad); // integrate position
len += delta; // accumulate distance
iterations++;
}
int drawfieldline = 1;
// only draw the field line for this seed if we have enough points.
// If we haven't reached the minimum field line length, we'll
// drop the whole field line.
if (pointcount < 2 || len < minlen)
drawfieldline = 0;
// only draw if bounding sphere diameter exceeds minlen
if (drawfieldline)
{
float com[3];
vec_scale (com, 1.0f / (float) pointcount, comsum);
float minlen2 = minlen * minlen;
drawfieldline = 0;
int p;
for (p = 0; p < pointcount; p++)
{
if ((2.0f * distance2 (com, &points[p * 3])) > minlen2)
{
drawfieldline = 1;
break;
}
}
}
// only draw the field line if it met all selection criteria
if (drawfieldline)
{
cmdLineType.putdata (SOLIDLINE, cmdList);
cmdLineWidth.putdata ((int) thickness, cmdList);
cmdColorIndex.putdata (usecolor, cmdList);
DispCmdPolyLineArray cmdPolyLineArray;
cmdPolyLineArray.putdata (&points[0], pointcount, cmdList);
}
}
}
msg_timer_destroy (msgt);
if (printdonemesg)
msgInfo << "field line integration complete." << sendmsg;
}
