void WgModValue::Clear()
{
bool bModified = _field()->Value() != 0;
_field()->Clear();
if( bModified )
_field()->OnValueModified();
}
bool WgModValue::SetRange( Sint64 min, Sint64 max )
{
Sint64 val = _field()->Value();
bool retVal = _field()->SetRange(min,max);
if( val != _field()->Value() )
_field()->OnValueModified();
return retVal;
}
bool WgModValue::Set( Sint64 value, int scale )
{
if( _field()->Set(value,scale) )
{
_field()->OnValueModified();
return true;
}
else
return false;
}
double TurbulenceField::evaluateTurbulenceAtPosition(glm::vec3 p) {
assert(Grid3d::isPositionInGrid(p, _dx, _isize, _jsize, _ksize));
p -= glm::vec3(0.5*_dx, 0.5*_dx, 0.5*_dx);
int i, j, k;
double gx, gy, gz;
Grid3d::positionToGridIndex(p.x, p.y, p.z, _dx, &i, &j, &k);
Grid3d::GridIndexToPosition(i, j, k, _dx, &gx, &gy, &gz);
double inv_dx = 1 / _dx;
double ix = (p.x - gx)*inv_dx;
double iy = (p.y - gy)*inv_dx;
double iz = (p.z - gz)*inv_dx;
assert(ix >= 0 && ix < 1 && iy >= 0 && iy < 1 && iz >= 0 && iz < 1);
double points[8] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
if (_field.isIndexInRange(i, j, k)) { points[0] = _field(i, j, k); }
if (_field.isIndexInRange(i+1, j, k)) { points[1] = _field(i+1, j, k); }
if (_field.isIndexInRange(i, j+1, k)) { points[2] = _field(i, j+1, k); }
if (_field.isIndexInRange(i, j, k+1)) { points[3] = _field(i, j, k+1); }
if (_field.isIndexInRange(i+1, j, k+1)) { points[4] = _field(i+1, j, k+1); }
if (_field.isIndexInRange(i, j+1, k+1)) { points[5] = _field(i, j+1, k+1); }
if (_field.isIndexInRange(i+1, j+1, k)) { points[6] = _field(i+1, j+1, k); }
if (_field.isIndexInRange(i+1, j+1, k+1)) { points[7] = _field(i+1, j+1, k+1); }
return _trilinearInterpolate(points, ix, iy, iz);
}
void ScalarField::addCuboid(vmath::vec3 pos, double w, double h, double d) {
pos -= _gridOffset;
GridIndex gmin, gmax;
AABB bbox = AABB(pos, w, h, d);
Grid3d::getGridIndexBounds(bbox, _dx, _isize, _jsize, _ksize, &gmin, &gmax);
double eps = 10e-6;
vmath::vec3 gpos;
for (int k = gmin.k; k <= gmax.k; k++) {
for (int j = gmin.j; j <= gmax.j; j++) {
for (int i = gmin.i; i <= gmax.i; i++) {
if (_isMaxScalarFieldThresholdSet && _field(i, j, k) > _maxScalarFieldThreshold) {
continue;
}
gpos = Grid3d::GridIndexToPosition(i, j, k, _dx);
if (bbox.isPointInside(gpos)) {
addScalarFieldValue(i, j, k, _surfaceThreshold + eps);
if (_isWeightFieldEnabled) {
_weightField.add(i, j, k, (float)(_surfaceThreshold + eps));
}
}
}
}
}
}
void ScalarField::addPointValue(vmath::vec3 p, double scale) {
p -= _gridOffset;
GridIndex gmin, gmax;
Grid3d::getGridIndexBounds(p, _radius, _dx, _isize, _jsize, _ksize, &gmin, &gmax);
vmath::vec3 gpos;
vmath::vec3 v;
double rsq = _radius*_radius;
double distsq;
double weight;
for (int k = gmin.k; k <= gmax.k; k++) {
for (int j = gmin.j; j <= gmax.j; j++) {
for (int i = gmin.i; i <= gmax.i; i++) {
if (_isMaxScalarFieldThresholdSet && _field(i, j, k) > _maxScalarFieldThreshold) {
continue;
}
gpos = Grid3d::GridIndexToPosition(i, j, k, _dx);
v = gpos - p;
distsq = vmath::dot(v, v);
if (distsq < rsq) {
weight = _evaluateTricubicFieldFunctionForRadiusSquared(distsq);
addScalarFieldValue(i, j, k, weight*scale);
if (_isWeightFieldEnabled) {
_weightField.add(i, j, k, (float)weight);
}
}
}
}
}
}
double ScalarField::getScalarFieldValue(int i, int j, int k) {
FLUIDSIM_ASSERT(Grid3d::isGridIndexInRange(i, j, k, _field.width, _field.height, _field.depth));
double val = _field(i, j, k);
if (_isVertexSolid(i, j, k) && val > _surfaceThreshold) {
val = _surfaceThreshold;
}
return val;
}
double ScalarField::tricubicInterpolation(vmath::vec3 p) {
if (!Grid3d::isPositionInGrid(p.x, p.y, p.z, _dx, _isize, _jsize, _ksize)) {
return 0.0;
}
int i, j, k;
double gx, gy, gz;
Grid3d::positionToGridIndex(p.x, p.y, p.z, _dx, &i, &j, &k);
Grid3d::GridIndexToPosition(i, j, k, _dx, &gx, &gy, &gz);
double inv_dx = 1 / _dx;
double ix = (p.x - gx)*inv_dx;
double iy = (p.y - gy)*inv_dx;
double iz = (p.z - gz)*inv_dx;
int refi = i - 1;
int refj = j - 1;
int refk = k - 1;
double min = std::numeric_limits<double>::infinity();
double max = -std::numeric_limits<double>::infinity();
double points[4][4][4];
for (int pk = 0; pk < 4; pk++) {
for (int pj = 0; pj < 4; pj++) {
for (int pi = 0; pi < 4; pi++) {
if (_field.isIndexInRange(pi + refi, pj + refj, pk + refk)) {
points[pi][pj][pk] = _field(pi + refi, pj + refj, pk + refk);
if (points[pi][pj][pk] < min) {
min = points[pi][pj][pk];
} else if (points[pi][pj][pk] > max) {
max = points[pi][pj][pk];
}
} else {
points[pi][pj][pk] = 0;
}
}
}
}
double val = Interpolation::tricubicInterpolate(points, ix, iy, iz);
if (val < min) {
val = min;
} else if (val > max) {
val = max;
}
return val;
}
void ScalarField::applyWeightField() {
if (!_isWeightFieldEnabled) {
return;
}
for (int k = 0; k < _ksize; k++) {
for (int j = 0; j < _jsize; j++) {
for (int i = 0; i < _isize; i++) {
float weight = _weightField(i, j, k);
if (weight > 0.0) {
float v = _field(i, j, k) / weight;
setScalarFieldValue(i, j, k, v);
}
}
}
}
}
void ScalarField::getScalarField(Array3d<float> &field) {
FLUIDSIM_ASSERT(field.width == _field.width &&
field.height == _field.height &&
field.depth == _field.depth);
double val;
for (int k = 0; k < field.depth; k++) {
for (int j = 0; j < field.height; j++) {
for (int i = 0; i < field.width; i++) {
val = _field(i, j, k);
if (_isVertexSolid(i, j, k) && val > _surfaceThreshold) {
val = _surfaceThreshold;
}
field.set(i, j, k, (float)val);
}
}
}
}
double ScalarField::getRawScalarFieldValue(int i, int j, int k) {
FLUIDSIM_ASSERT(Grid3d::isGridIndexInRange(i, j, k, _field.width, _field.height, _field.depth));
return _field(i, j, k);
}
