//////////////////////////////////////////////////////////////////////////
// specify a set of seed points regularly generated over the specified
// spatial interval. Points can be in axis aligned dimension 0, 1, 2, 3
//////////////////////////////////////////////////////////////////////////
void OSUFlow::SetRegularSeedPoints(const float min[3],
const float max[3],
const size_t numSeeds[3])
{
for(int iFor = 0; iFor < 3; iFor++)
{
minRakeExt[iFor] = min[iFor];
maxRakeExt[iFor] = max[iFor];
}
this->numSeeds[0] = (unsigned int)numSeeds[0];
this->numSeeds[1] = (unsigned int)numSeeds[1];
this->numSeeds[2] = (unsigned int)numSeeds[2];
bUseRandomSeeds = false;
// generate seeds
nSeeds = numSeeds[0]*numSeeds[1]*numSeeds[2];
seedPtr = new VECTOR3[nSeeds];
if (seedPtr!=NULL) delete[]seedPtr;
SeedGenerator* pSeedGenerator = new SeedGenerator((const float*)minRakeExt,
(const float*)maxRakeExt,
(const size_t*)numSeeds);
pSeedGenerator->GetSeeds(seedPtr, bUseRandomSeeds);
delete pSeedGenerator;
}
void OSUFlow::SetRandomSeedPoints(const float min[3],
const float max[3],
int num)
{
for(int iFor = 0; iFor < 3; iFor++)
{
minRakeExt[iFor] = min[iFor];
maxRakeExt[iFor] = max[iFor];
}
this->numSeeds[0] = num;
this->numSeeds[1] = 1;
this->numSeeds[2] = 1;
bUseRandomSeeds = true;
// generate seeds
nSeeds = numSeeds[0]*numSeeds[1]*numSeeds[2];
if (seedPtr!=NULL) delete[]seedPtr;
seedPtr = new VECTOR3[nSeeds];
size_t SeedSize[3];
SeedSize[0] = numSeeds[0];
SeedSize[1] = numSeeds[1];
SeedSize[2] = numSeeds[2];
SeedGenerator* pSeedGenerator = new SeedGenerator((const float*)minRakeExt,
(const float*)maxRakeExt,
(const size_t*)SeedSize);
pSeedGenerator->GetSeeds(seedPtr, bUseRandomSeeds);
delete pSeedGenerator;
//printf(" done\n");
}
//////////////////////////////////////////////////////////////////////////////
// all particles start at the same time: currentT
bool OSUFlow::GenPathLines(list<vtListTimeSeedTrace*>& listSeedTraces,
TIME_DIR dir,
int maxPoints,
float currentT)
{
if (has_data == false) DeferredLoadData();
// first generate seeds if not exist before
if (seedPtr==NULL) {
nSeeds = numSeeds[0]*numSeeds[1]*numSeeds[2];
seedPtr = new VECTOR3[nSeeds];
SeedGenerator* pSeedGenerator = new SeedGenerator((const float*)minRakeExt,
(const float*)maxRakeExt,
(const size_t*)numSeeds);
pSeedGenerator->GetSeeds(seedPtr, bUseRandomSeeds);
delete pSeedGenerator;
}
listSeedTraces.clear();
// execute streamline
vtCPathLine* pPathLine;
pPathLine = new vtCPathLine(flowField);
InitFieldLine(pPathLine, maxPoints);
pPathLine->SetTimeDir(dir);
pPathLine->setSeedPoints(seedPtr, nSeeds, currentT);
pPathLine->execute(listSeedTraces);
// release resource
delete pPathLine;
return true;
}
///////////////////////////////////////////////////////////////
//
// Use preset streakline seeds, all starting from current_time
//
bool OSUFlow::GenStreakLines(vtStreakTraces& streakTraces, TIME_DIR dir,
float current_time)
{
if (has_data == false) DeferredLoadData();
if (seedPtr==NULL) {
nSeeds = numSeeds[0]*numSeeds[1]*numSeeds[2];
seedPtr = new VECTOR3[nSeeds];
SeedGenerator* pSeedGenerator = new SeedGenerator((const float*)minRakeExt,
(const float*)maxRakeExt,
(const size_t*)numSeeds);
pSeedGenerator->GetSeeds(seedPtr, bUseRandomSeeds);
delete pSeedGenerator;
}
vtCStreakLine* pStreakLine = new vtCStreakLine(flowField);
float currentT = current_time;
InitFieldLine(pStreakLine, 1000);
pStreakLine->SetTimeDir(dir);
pStreakLine->setSeedPoints(seedPtr, nSeeds, currentT);
pStreakLine->execute((void*) ¤tT, streakTraces);
delete pStreakLine;
return true;
}
//////////////////////////////////////////////////////////////////////////
// generate streamlines
// input
// listSeedTraces: STL list to keep the advection result
// maxPoints: how many advection points each streamline
// randomSeed: seed for random number generator
//////////////////////////////////////////////////////////////////////////
bool OSUFlow::GenStreamLines(list<vtListSeedTrace*>& listSeedTraces,
TRACE_DIR traceDir,
int maxPoints,
unsigned int randomSeed)
{
if (has_data == false) DeferredLoadData();
// first generate seeds
if (seedPtr==NULL) {
nSeeds = numSeeds[0]*numSeeds[1]*numSeeds[2];
seedPtr = new VECTOR3[nSeeds];
SeedGenerator* pSeedGenerator = new SeedGenerator((const float*)minRakeExt,
(const float*)maxRakeExt,
(const size_t*)numSeeds);
pSeedGenerator->GetSeeds(seedPtr, bUseRandomSeeds);
delete pSeedGenerator;
}
// or, seeds have already been generated previously, do nothing.
listSeedTraces.clear();
// execute streamline
vtCStreamLine* pStreamLine;
float currentT = 0.0;
pStreamLine = new vtCStreamLine(flowField);
switch(traceDir)
{
case BACKWARD_DIR:
pStreamLine->setForwardTracing(false);
break;
case FORWARD_DIR:
pStreamLine->setBackwardTracing(false);
break;
case BACKWARD_AND_FORWARD:
break;
}
InitFieldLine(pStreamLine, maxPoints);
pStreamLine->setSeedPoints(seedPtr, nSeeds, currentT);
pStreamLine->execute((void *)¤tT, listSeedTraces);
// release resource
delete pStreamLine;
return true;
}