void mitk::BaseRenderer::SetGeometryTime(const itk::EventObject & geometryTimeEvent)
{
const SliceNavigationController::GeometryTimeEvent * timeEvent =
dynamic_cast<const SliceNavigationController::GeometryTimeEvent *>(&geometryTimeEvent);
assert(timeEvent!=NULL);
SetTimeStep(timeEvent->GetPos());
}
void MessageArea::WriteLine(const string_t &text)
{
GetConsole().WriteLine(0, text);
Line line;
line.time = 5; // timeout
line.str = text;
_lines.push_front(line);
SetTimeStep(true);
}
void vpRagdollWorld::Create()
{
int i, j;
SetGravity(Vec3(0.0, 0.0, -10.0));
floor.m_szName = string("floor");
floor.SetGround();
floor.AddGeometry(new vpBox(Vec3(100.0, 100.0, 5.0)), Vec3(0.0, 0.0, -10.0));
AddBody(&floor);
for ( i = 0; i < NUM_PUPPET; i++ )
for ( j = 0; j < NUM_PUPPET; j++ )
{
puppet[i][j].Create(this);
//puppet[i][j].G.SetFrame(Vec3(12 * j, 8 * i, 0));
puppet[i][j].G.SetFrame(Vec3(12 * (j - NUM_PUPPET / 2), 8 * (i - NUM_PUPPET / 2), 0));
}
for ( i = 0; i < NUM_STONE; i++ )
{
stone[i].AddGeometry(new vpSphere(1));
AddBody(&stone[i]);
stone[i].SetFrame(Vec3(0, 3*i, -100));
//stone[i].SetInertia(Inertia(5.0));
//sprintf(stone[i].m_szName, "ball%i", i);
}
//EnableCollision(false);
//SetIntegrator(VP::IMPLICIT_EULER_FAST);
SetIntegrator(VP::EULER);
SetTimeStep(0.001);
Initialize();
renderer.SetTarget(this);
if ( pWoodMaterial )
for ( i = 0; i < GetNumBody(); i++ ) renderer.SetMaterial(GetBody(i), pWoodMaterial);
if ( pMarbleMaterial )
{
renderer.SetMaterial(&floor, pMarbleMaterial);
for ( i = 0; i < NUM_STONE; i++ ) renderer.SetMaterial(&stone[i], pMarbleMaterial);
for ( i = 0; i < NUM_PUPPET; i++ )
for ( j = 0; j < NUM_PUPPET; j++ )
for ( int k = 0; k < NUM_ROPE; k++ )
renderer.SetMaterial(&puppet[i][j].B_rope[k], pMarbleMaterial);
}
}
void MessageArea::OnTimeStep(float dt)
{
for( size_t i = 0; i < _lines.size(); ++i )
_lines[i].time -= dt;
while( !_lines.empty() && _lines.back().time <= 0 )
_lines.pop_back();
if( _lines.empty() )
{
SetTimeStep(false);
return;
}
}
bool GLGPUDataset::LoadTimeStep(int timestep, int slot)
{
assert(timestep>=0 && timestep<=_filenames.size());
bool succ = false;
const std::string &filename = _filenames[timestep];
// load
if (OpenBDATDataFile(filename, slot)) succ = true;
else if (OpenLegacyDataFile(filename, slot)) succ = true;
if (!succ) return false;
// if (_precompute_supercurrent)
// ComputeSupercurrentField(slot);
// ModulateKex(slot);
// fprintf(stderr, "loaded time step %d, %s\n", timestep, _filenames[timestep].c_str());
SetTimeStep(timestep, slot);
return true;
}
void
QueryAttributes::SetFromNode(DataNode *parentNode)
{
if(parentNode == 0)
return;
DataNode *searchNode = parentNode->GetNode("QueryAttributes");
if(searchNode == 0)
return;
DataNode *node;
if((node = searchNode->GetNode("resultsMessage")) != 0)
SetResultsMessage(node->AsString());
if((node = searchNode->GetNode("resultsValue")) != 0)
SetResultsValue(node->AsDoubleVector());
if((node = searchNode->GetNode("timeStep")) != 0)
SetTimeStep(node->AsInt());
if((node = searchNode->GetNode("varTypes")) != 0)
SetVarTypes(node->AsIntVector());
if((node = searchNode->GetNode("pipeIndex")) != 0)
SetPipeIndex(node->AsInt());
if((node = searchNode->GetNode("xUnits")) != 0)
SetXUnits(node->AsString());
if((node = searchNode->GetNode("yUnits")) != 0)
SetYUnits(node->AsString());
if((node = searchNode->GetNode("floatFormat")) != 0)
SetFloatFormat(node->AsString());
if((node = searchNode->GetNode("xmlResult")) != 0)
SetXmlResult(node->AsString());
if((node = searchNode->GetNode("suppressOutput")) != 0)
SetSuppressOutput(node->AsBool());
if((node = searchNode->GetNode("queryInputParams")) != 0)
SetQueryInputParams(node->AsMapNode());
if((node = searchNode->GetNode("defaultName")) != 0)
SetDefaultName(node->AsString());
if((node = searchNode->GetNode("defaultVars")) != 0)
SetDefaultVars(node->AsStringVector());
}
void vpSiloWorld::Create(void)
{
vpMaterial::GetDefaultMaterial()->SetRestitution(0.3);
vpMaterial::GetDefaultMaterial()->SetDynamicFriction(0.3);
for ( int i = 0; i < NUM_SILO_LEVEL; i++ )
{
for ( int j = 0; j < NUM_SILO_BLOCKS; j++ )
{
block[i][j].AddGeometry(new vpBox(Vec3(1, 2, 1)));
block[i][j].SetFrame(Exp(se3(0, 0, (scalar)(j + (scalar)0.5 * (i % 2)) / (scalar)NUM_SILO_BLOCKS * M_2PI, 0, 0, 0)) * SE3(Vec3(4.4, 0, 1.01 * i)));
AddBody(&block[i][j]);
block[i][j].SetInertia(Inertia(1));
}
}
for ( int i = 0; i < NUM_BALL; i++ )
{
ball[i].AddGeometry(new vpSphere(0.25));
ball[i].SetFrame(Vec3(drand(2.0), drand(2.0), NUM_SILO_LEVEL + (25.0 / NUM_BALL) * i));
ball[i].SetGenVelocity(se3(0,0,0,drand(0.1), drand(0.1), drand(0.1)));
ball[i].SetInertia(Inertia(0.5));
AddBody(&ball[i]);
}
floor.AddGeometry(new vpBox(Vec3(100, 100, 1)));
floor.SetFrame(Vec3(0, 0, -1.0));
floor.SetGround();
AddBody(&floor);
roof.AddGeometry(new vpBox(Vec3(10, 10, 1)), Vec3(0.0, 0.0, -1));
roof.SetFrame(Vec3(0, 0, -10));
AddBody(&roof);
//SetIntegrator(VP::IMPLICIT_EULER);
SetIntegrator(VP::EULER);
SetTimeStep(0.005);
SetGravity(Vec3(0.0, 0.0, -10.0));
Initialize();
BackupState();
renderer.SetTarget(this);
if ( materialArray.size() )
{
renderer.SetMaterial(&floor, materialArray[0]);
renderer.SetMaterial(&roof, materialArray[1]);
for ( int i = 0; i < NUM_SILO_LEVEL; i++ )
{
for ( int j = 0; j < NUM_SILO_BLOCKS; j++ )
{
renderer.SetMaterial(&block[i][j], materialArray[2]);
}
}
for ( int i = 0; i < NUM_BALL; i++ )
{
renderer.SetMaterial(&ball[i], materialArray[1]);
}
}
}
/**
* @fn Flo::InitializeSlabOps()
* @brief Initializes the SlabOps used in the fluid simulation
*
* Here we initialize the slab operations, passing them parameters such
* as input textures, and fragment programs.
*/
void Flo::_InitializeSlabOps(CGcontext context)
{
// Compute the minimum and maximum vertex and texture coordinates for
// rendering the slab interiors (sans boundaries).
float xMin = 1.0f / (float)_iWidth; // one pixel from left
float xMax = 1.0f - 1.0f / (float)_iWidth; // one pixel from right
float yMin = 1.0f / (float)_iHeight; // on pixel from bottom
float yMax = 1.0f - 1.0f / (float)_iHeight; // one pixel from top
float sMin = 1.0f; // the same, this time in
float sMax = (float)_iWidth - 1.0f; // texture coordinates
float tMin = 1.0f;
float tMax = (float)_iHeight - 1.0f;
// Add Impulse. This renders a Gaussian "splat" into the specified texture,
// with the specified position, radius, and color.
_addImpulse.InitializeFP(context, "../geep/programs/splat.cg");
_addImpulse.SetTextureParameter("base", _iTextures[TEXTURE_VELOCITY]);
_addImpulse.SetFragmentParameter2f("windowDims", _iWidth, _iHeight);
_addImpulse.SetTexCoordRect(0, sMin, tMin, sMax, tMax);
_addImpulse.SetSlabRect(xMin, yMin, xMax, yMax);
_addImpulse.SetOutputTexture(_iTextures[TEXTURE_VELOCITY],
_iWidth, _iHeight);
// Advection: This advects a field by the moving velocity field. This is
// used to advect both velocity and scalar values, such as mass. The result
// of applying this to the velocity field is a moving but divergent velocity
// field. The next few steps correct that divergence to give a divergence-
// free velocity field.
_advect.InitializeFP(context, "flo.cg", "advect");
_advect.SetTextureParameter("u", _iTextures[TEXTURE_VELOCITY]);
_advect.SetTextureParameter("x", _iTextures[TEXTURE_VELOCITY]);
_advect.SetFragmentParameter1f("rdx", 1.0f / _dx);
_advect.SetTexCoordRect(0, sMin, tMin, sMax, tMax);
_advect.SetSlabRect(xMin, yMin, xMax, yMax);
_advect.SetOutputTexture(_iTextures[TEXTURE_VELOCITY], _iWidth, _iHeight);
// Divergence of velocity: This computes how divergent the velocity field is
// (how much in/out flow there is at every point). Used as input to the
// Poisson solver, below.
_divergence.InitializeFP(context, "flo.cg", "divergence");
_divergence.SetTextureParameter("w", _iTextures[TEXTURE_VELOCITY]);
_divergence.SetFragmentParameter1f("halfrdx", 0.5f / _dx);
_divergence.SetTexCoordRect(0, sMin, tMin, sMax, tMax);
_divergence.SetSlabRect(xMin, yMin, xMax, yMax);
_divergence.SetOutputTexture(_iTextures[TEXTURE_DIVERGENCE],
_iWidth, _iHeight);
// Poisson-pressure solver: By running this Jacobi Relaxation solver for
// multiple iterations, this solves for the pressure disturbance in the
// fluid given the divergence of the velocity.
_poissonSolver.InitializeFP(context, "flo.cg", "jacobi");
_poissonSolver.SetTextureParameter("x", _iTextures[TEXTURE_PRESSURE]);
_poissonSolver.SetTextureParameter("b", _iTextures[TEXTURE_DIVERGENCE]);
_poissonSolver.SetFragmentParameter1f("alpha", -_dx * _dx);
_poissonSolver.SetFragmentParameter1f("rBeta", 0.25f);
_poissonSolver.SetTexCoordRect(0, sMin, tMin, sMax, tMax);
_poissonSolver.SetSlabRect(xMin, yMin, xMax, yMax);
_poissonSolver.SetOutputTexture(_iTextures[TEXTURE_PRESSURE],
_iWidth, _iHeight);
// Subtract Gradient. After solving for the pressure disturbance, this
// subtracts the pressure gradient from the divergent velocity field to
// give a divergence-free field.
_subtractGradient.InitializeFP(context, "flo.cg", "gradient");
_subtractGradient.SetTextureParameter("p", _iTextures[TEXTURE_PRESSURE]);
_subtractGradient.SetTextureParameter("w", _iTextures[TEXTURE_VELOCITY]);
_subtractGradient.SetFragmentParameter1f("halfrdx", 0.5f / _dx);
_subtractGradient.SetTexCoordRect(0, sMin, tMin, sMax, tMax);
_subtractGradient.SetSlabRect(xMin, yMin, xMax, yMax);
_subtractGradient.SetOutputTexture(_iTextures[TEXTURE_VELOCITY],
_iWidth, _iHeight);
// vorticity computation.
_vorticity.InitializeFP(context, "flo.cg", "vorticity");
_vorticity.SetTextureParameter("u", _iTextures[TEXTURE_VELOCITY]);
_vorticity.SetFragmentParameter1f("halfrdx", 0.5f / _dx);
_vorticity.SetTexCoordRect(0, sMin, tMin, sMax, tMax);
_vorticity.SetSlabRect(xMin, yMin, xMax, yMax);
_vorticity.SetOutputTexture(_iTextures[TEXTURE_VORTICITY],
_iWidth, _iHeight);
// vorticity confinement force computation.
_vorticityForce.InitializeFP(context, "flo.cg", "vortForce");
_vorticityForce.SetTextureParameter("vort", _iTextures[TEXTURE_VORTICITY]);
_vorticityForce.SetTextureParameter("u", _iTextures[TEXTURE_VELOCITY]);
_vorticityForce.SetFragmentParameter1f("halfrdx", 0.5f / _dx);
_vorticityForce.SetFragmentParameter2f("dxscale",
_rVorticityConfinementScale * _dx,
_rVorticityConfinementScale * _dx);
_vorticityForce.SetTexCoordRect(0, sMin, tMin, sMax, tMax);
_vorticityForce.SetSlabRect(xMin, yMin, xMax, yMax);
_vorticityForce.SetOutputTexture(_iTextures[TEXTURE_VELOCITY],
_iWidth, _iHeight);
// This applies pure neumann boundary conditions (see floPoissonBC.cg) to
// the pressure field once per iteration of the poisson-pressure jacobi
// solver. Also no-slip BCs to velocity once per time step.
_boundaries.InitializeFP(context, "flo.cg", "boundary");
_boundaries.SetTexCoordRect(0, 0, _iWidth, _iHeight);
_boundaries.SetTexResolution(_iWidth, _iHeight);
_updateOffsets.InitializeFP(context, "flo.cg",
"updateOffsets");
_updateOffsets.SetTextureParameter("b", _iBCTexture);
_updateOffsets.SetTextureParameter("offsetTable", _iVelocityOffsetTexture);
_updateOffsets.SetTexCoordRect(0, 0, 0, _iWidth, _iHeight);
_updateOffsets.SetSlabRect(xMin, yMin, xMax, yMax);
_updateOffsets.SetOutputTexture(_iTextures[TEXTURE_VELOCITY_OFFSETS],
_iWidth, _iHeight);
// setup the arbitrary boundary operations.
_arbitraryVelocityBC.InitializeFP(context, "flo.cg",
"arbitraryVelocityBoundary");
_arbitraryVelocityBC.SetTextureParameter("u", _iTextures[TEXTURE_VELOCITY]);
_arbitraryVelocityBC.SetTextureParameter("offsets",
_iTextures[TEXTURE_VELOCITY_OFFSETS]);
_arbitraryVelocityBC.SetTexCoordRect(0, 0, 0, _iWidth, _iHeight);
_arbitraryVelocityBC.SetSlabRect(xMin, yMin, xMax, yMax);
_arbitraryVelocityBC.SetOutputTexture(_iTextures[TEXTURE_VELOCITY],
_iWidth, _iHeight);
_arbitraryPressureBC.InitializeFP(context, "flo.cg",
"arbitraryPressureBoundary");
_arbitraryPressureBC.SetTextureParameter("p", _iTextures[TEXTURE_PRESSURE]);
_arbitraryPressureBC.SetTextureParameter("offsets", _iTextures[TEXTURE_PRESSURE_OFFSETS]);
_arbitraryPressureBC.SetTexCoordRect(0, 0, 0, _iWidth, _iHeight);
_arbitraryPressureBC.SetSlabRect(xMin, yMin, xMax, yMax);
_arbitraryPressureBC.SetOutputTexture(_iTextures[TEXTURE_PRESSURE],
_iWidth, _iHeight);
// Display: These ops are used to display scalar and vector fields with
// and without bilinear interpolation.
_displayVector.InitializeFP(context, "flo.cg", "displayVector");
_displayVector.SetTexCoordRect(0, 0, _iWidth, _iHeight);
_displayVectorBilerp.InitializeFP(context, "flo.cg", "displayVectorBilerp");
_displayVectorBilerp.SetTexCoordRect(0, 0, _iWidth, _iHeight);
_displayScalar.InitializeFP(context, "flo.cg", "displayScalar");
_displayScalar.SetTexCoordRect(0, 0, _iWidth, _iHeight);
_displayScalarBilerp.InitializeFP(context, "flo.cg", "displayScalarBilerp");
_displayScalarBilerp.SetTexCoordRect(0, 0, _iWidth, _iHeight);
// to ensure it gets set in the advection operation
SetTimeStep(_rTimestep);
}
void
QueryAttributes::SetFromNode(DataNode *parentNode)
{
if(parentNode == 0)
return;
DataNode *searchNode = parentNode->GetNode("QueryAttributes");
if(searchNode == 0)
return;
DataNode *node;
if((node = searchNode->GetNode("name")) != 0)
SetName(node->AsString());
if((node = searchNode->GetNode("variables")) != 0)
SetVariables(node->AsStringVector());
if((node = searchNode->GetNode("resultsMessage")) != 0)
SetResultsMessage(node->AsString());
if((node = searchNode->GetNode("worldPoint")) != 0)
SetWorldPoint(node->AsDoubleArray());
if((node = searchNode->GetNode("domain")) != 0)
SetDomain(node->AsInt());
if((node = searchNode->GetNode("element")) != 0)
SetElement(node->AsInt());
if((node = searchNode->GetNode("resultsValue")) != 0)
SetResultsValue(node->AsDoubleVector());
if((node = searchNode->GetNode("elementType")) != 0)
{
// Allow enums to be int or string in the config file
if(node->GetNodeType() == INT_NODE)
{
int ival = node->AsInt();
if(ival >= 0 && ival < 2)
SetElementType(ElementType(ival));
}
else if(node->GetNodeType() == STRING_NODE)
{
ElementType value;
if(ElementType_FromString(node->AsString(), value))
SetElementType(value);
}
}
if((node = searchNode->GetNode("timeStep")) != 0)
SetTimeStep(node->AsInt());
if((node = searchNode->GetNode("varTypes")) != 0)
SetVarTypes(node->AsIntVector());
if((node = searchNode->GetNode("dataType")) != 0)
{
// Allow enums to be int or string in the config file
if(node->GetNodeType() == INT_NODE)
{
int ival = node->AsInt();
if(ival >= 0 && ival < 2)
SetDataType(DataType(ival));
}
else if(node->GetNodeType() == STRING_NODE)
{
DataType value;
if(DataType_FromString(node->AsString(), value))
SetDataType(value);
}
}
if((node = searchNode->GetNode("pipeIndex")) != 0)
SetPipeIndex(node->AsInt());
if((node = searchNode->GetNode("useGlobalId")) != 0)
SetUseGlobalId(node->AsBool());
if((node = searchNode->GetNode("xUnits")) != 0)
SetXUnits(node->AsString());
if((node = searchNode->GetNode("yUnits")) != 0)
SetYUnits(node->AsString());
if((node = searchNode->GetNode("darg1")) != 0)
SetDarg1(node->AsDoubleVector());
if((node = searchNode->GetNode("darg2")) != 0)
SetDarg2(node->AsDoubleVector());
if((node = searchNode->GetNode("floatFormat")) != 0)
SetFloatFormat(node->AsString());
if((node = searchNode->GetNode("xmlResult")) != 0)
SetXmlResult(node->AsString());
}
void SetupScenario()
{
std::string scenario_name = "";
gArgParser->ParseString("scenario", scenario_name);
if (scenario_name == "imitate_step")
{
auto scene = std::shared_ptr<cScenarioImitateStep>(new cScenarioImitateStep());
scene->SetTimeStep(cOptScenario::gTimeStep);
scene->SetExpPoolSize(gNumThreads);
gScenario = scene;
}
else if (scenario_name == "train_hike")
{
auto scene = std::shared_ptr<cScenarioTrainHike>(new cScenarioTrainHike());
scene->SetTimeStep(cOptScenario::gTimeStep);
scene->SetExpPoolSize(gNumThreads);
gScenario = scene;
}
else if (scenario_name == "train_soccer")
{
auto scene = std::shared_ptr<cScenarioTrainSoccer>(new cScenarioTrainSoccer());
scene->SetTimeStep(cOptScenario::gTimeStep);
scene->SetExpPoolSize(gNumThreads);
gScenario = scene;
}
else if (scenario_name == "poli_eval")
{
auto scene = std::shared_ptr<cOptScenarioPoliEval>(new cOptScenarioPoliEval());
scene->SetTimeStep(cOptScenario::gTimeStep);
scene->SetPoolSize(gNumThreads);
gScenario = scene;
}
else if (scenario_name == "imitate_eval")
{
auto scene = std::shared_ptr<cOptScenarioImitateEval>(new cOptScenarioImitateEval());
scene->SetTimeStep(cOptScenario::gTimeStep);
scene->SetPoolSize(gNumThreads);
gScenario = scene;
}
else if (scenario_name == "imitate_target_eval")
{
auto scene = std::shared_ptr<cOptScenarioImitateTargetEval>(new cOptScenarioImitateTargetEval());
scene->SetTimeStep(cOptScenario::gTimeStep);
scene->SetPoolSize(gNumThreads);
gScenario = scene;
}
else if (scenario_name == "imitate_step_eval")
{
auto scene = std::shared_ptr<cOptScenarioImitateStepEval>(new cOptScenarioImitateStepEval());
scene->SetTimeStep(cOptScenario::gTimeStep);
scene->SetPoolSize(gNumThreads);
gScenario = scene;
}
else if (scenario_name == "hike_eval")
{
auto scene = std::shared_ptr<cOptScenarioHikeEval>(new cOptScenarioHikeEval());
scene->SetTimeStep(cOptScenario::gTimeStep);
scene->SetPoolSize(gNumThreads);
gScenario = scene;
}
else if (scenario_name == "soccer_eval")
{
auto scene = std::shared_ptr<cOptScenarioSoccerEval>(new cOptScenarioSoccerEval());
scene->SetTimeStep(cOptScenario::gTimeStep);
scene->SetPoolSize(gNumThreads);
gScenario = scene;
}
else
{
printf("No valid scenario specified\n");
}
if (gScenario != NULL)
{
gScenario->ParseArgs(gArgParser);
gScenario->Init();
printf("Loaded scenario: %s\n", gScenario->GetName().c_str());
}
}
void MessageArea::Clear()
{
_lines.clear();
SetTimeStep(false);
}
