// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void XtArrayInitialization::initialize(EMMPM_Data::Pointer data)
{
size_t total;
total = data->rows * data->columns;
const float rangeMin = 0.0f;
const float rangeMax = 1.0f;
typedef boost::uniform_real<> NumberDistribution;
typedef boost::mt19937 RandomNumberGenerator;
typedef boost::variate_generator<RandomNumberGenerator&,
NumberDistribution> Generator;
NumberDistribution distribution(rangeMin, rangeMax);
RandomNumberGenerator generator;
Generator numberGenerator(generator, distribution);
generator.seed(EMMPM_getMilliSeconds()); // seed with the current time
/* Initialize classification of each pixel randomly with a uniform disribution */
for (size_t i = 0; i < total; i++)
{
data->xt[i] = numberGenerator() * data->classes;
}
}
// -----------------------------------------------------------------------------
//Function to generate a randomized list from a given input list
// -----------------------------------------------------------------------------
VoxelUpdateList::Pointer BFReconstructionEngine::GenRandList(VoxelUpdateList::Pointer InpList)
{
VoxelUpdateList::Pointer OpList;
const uint32_t rangeMin = 0;
const uint32_t rangeMax = std::numeric_limits<uint32_t>::max();
typedef boost::uniform_int<uint32_t> NumberDistribution;
typedef boost::mt19937 RandomNumberGenerator;
typedef boost::variate_generator<RandomNumberGenerator&, NumberDistribution> Generator;
NumberDistribution distribution(rangeMin, rangeMax);
RandomNumberGenerator generator;
Generator numberGenerator(generator, distribution);
boost::uint32_t arg = static_cast<boost::uint32_t>(EIMTOMO_getMilliSeconds());
generator.seed(arg); // seed with the current time
int32_t ArraySize = InpList.NumElts;
OpList.NumElts = ArraySize;
OpList.Array = (struct ImgIdx*)(malloc(ArraySize * sizeof(struct ImgIdx)));
size_t dims[3] =
{ ArraySize, 0, 0};
Int32ArrayType::Pointer Counter = Int32ArrayType::New(dims, "Counter");
for (int32_t j_new = 0; j_new < ArraySize; j_new++)
{
Counter->d[j_new] = j_new;
}
for(int32_t test_iter = 0; test_iter < InpList.NumElts; test_iter++)
{
int32_t Index = numberGenerator() % ArraySize;
OpList.Array[test_iter] = InpList.Array[Counter->d[Index]];
Counter->d[Index] = Counter->d[ArraySize - 1];
ArraySize--;
}
#ifdef DEBUG
if(getVerbose()) { std::cout << "Input" << std::endl; }
maxList(InpList);
if(getVerbose()) { std::cout << "Output" << std::endl; }
maxList(OpList);
#endif //Debug
return OpList;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int64_t EBSDSegmentFeatures::getSeed(int32_t gnum)
{
setErrorCondition(0);
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(getDataContainerName());
size_t totalPoints = m_FeatureIdsPtr.lock()->getNumberOfTuples();
int64_t seed = -1;
Generator& numberGenerator = *m_NumberGenerator;
while (seed == -1 && m_TotalRandomNumbersGenerated < totalPoints)
{
// Get the next voxel index in the precomputed list of voxel seeds
int64_t randpoint = numberGenerator();
m_TotalRandomNumbersGenerated++; // Increment this counter
if (m_FeatureIds[randpoint] == 0) // If the GrainId of the voxel is ZERO then we can use this as a seed point
{
if ((m_UseGoodVoxels == false || m_GoodVoxels[randpoint] == true) && m_CellPhases[randpoint] > 0)
{
seed = randpoint;
}
}
}
if (seed >= 0)
{
m_FeatureIds[seed] = gnum;
QVector<size_t> tDims(1, gnum + 1);
m->getAttributeMatrix(getCellFeatureAttributeMatrixName())->resizeAttributeArrays(tDims);
updateFeatureInstancePointers();
}
return seed;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
uint32_t BFReconstructionEngine::RandomizedPartition(RealArrayType::Pointer A, uint32_t p, uint32_t r)
{
const uint32_t rangeMin = 0;
const uint32_t rangeMax = std::numeric_limits<uint32_t>::max();
typedef boost::uniform_int<uint32_t> NumberDistribution;
typedef boost::mt19937 RandomNumberGenerator;
typedef boost::variate_generator<RandomNumberGenerator&, NumberDistribution> Generator;
NumberDistribution distribution(rangeMin, rangeMax);
RandomNumberGenerator generator;
Generator numberGenerator(generator, distribution);
boost::uint32_t arg = static_cast<boost::uint32_t>(EIMTOMO_getMilliSeconds());
generator.seed(arg); // seed with the current time
Real_t temp;
uint32_t j = p + numberGenerator() % (r - p + 1); //rand()%(r-p+1);
temp = A->d[r];
A->d[r] = A->d[j];
A->d[j] = temp;
return Partition(A, p, r);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void GroupMicroTextureRegions::randomizeFeatureIds(int64_t totalPoints, int64_t totalFeatures)
{
notifyStatusMessage(getHumanLabel(), "Randomizing Parent Ids");
// Generate an even distribution of numbers between the min and max range
const int32_t rangeMin = 0;
const int32_t rangeMax = totalFeatures - 1;
initializeVoxelSeedGenerator(rangeMin, rangeMax);
// Get a reference variable to the Generator object
Generator& numberGenerator = *m_NumberGenerator;
DataArray<int32_t>::Pointer rndNumbers = DataArray<int32_t>::CreateArray(totalFeatures, "_INTERNAL_USE_ONLY_NewFeatureIds");
int32_t* gid = rndNumbers->getPointer(0);
gid[0] = 0;
for (int64_t i = 1; i < totalFeatures; ++i)
{
gid[i] = i;
}
int32_t r = 0;
int32_t temp;
//--- Shuffle elements by randomly exchanging each with one other.
for (int64_t i = 1; i < totalFeatures; i++)
{
r = numberGenerator(); // Random remaining position.
if (r >= totalFeatures)
{
continue;
}
temp = gid[i];
gid[i] = gid[r];
gid[r] = temp;
}
// Now adjust all the Grain Id values for each Voxel
for (int64_t i = 0; i < totalPoints; ++i)
{
m_CellParentIds[i] = gid[m_CellParentIds[i]];
m_FeatureParentIds[m_FeatureIds[i]] = m_CellParentIds[i];
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void JumbleOrientations::execute()
{
setErrorCondition(0);
dataCheck();
if(getErrorCondition() < 0) { return; }
size_t totalPoints = m_FeatureIdsPtr.lock()->getNumberOfTuples();
int32_t totalFeatures = static_cast<int32_t>(m_FeaturePhasesPtr.lock()->getNumberOfTuples());
// Generate all the numbers up front
const int32_t rangeMin = 1;
const int32_t rangeMax = totalFeatures - 1;
typedef boost::uniform_int<int32_t> NumberDistribution;
typedef boost::mt19937 RandomNumberGenerator;
typedef boost::variate_generator < RandomNumberGenerator&,
NumberDistribution > Generator;
NumberDistribution distribution(rangeMin, rangeMax);
RandomNumberGenerator generator;
Generator numberGenerator(generator, distribution);
generator.seed(static_cast<boost::uint32_t>( QDateTime::currentMSecsSinceEpoch() )); // seed with the current time
int32_t r = 0;
float temp1 = 0.0f, temp2 = 0.0f, temp3 = 0.0f;
//--- Shuffle elements by randomly exchanging each with one other.
for (int32_t i = 1; i < totalFeatures; i++)
{
bool good = false;
while (good == false)
{
good = true;
r = numberGenerator(); // Random remaining position.
if (r >= totalFeatures) { good = false; }
if (m_FeaturePhases[i] != m_FeaturePhases[r]) { good = false; }
}
temp1 = m_FeatureEulerAngles[3 * i];
temp2 = m_FeatureEulerAngles[3 * i + 1];
temp3 = m_FeatureEulerAngles[3 * i + 2];
m_FeatureEulerAngles[3 * i] = m_FeatureEulerAngles[3 * r];
m_FeatureEulerAngles[3 * i + 1] = m_FeatureEulerAngles[3 * r + 1];
m_FeatureEulerAngles[3 * i + 2] = m_FeatureEulerAngles[3 * r + 2];
m_FeatureEulerAngles[3 * r] = temp1;
m_FeatureEulerAngles[3 * r + 1] = temp2;
m_FeatureEulerAngles[3 * r + 2] = temp3;
}
// Now adjust all the Euler angle values for each Voxel
for (size_t i = 0; i < totalPoints; ++i)
{
m_CellEulerAngles[3 * i] = m_FeatureEulerAngles[3 * (m_FeatureIds[i])];
m_CellEulerAngles[3 * i + 1] = m_FeatureEulerAngles[3 * (m_FeatureIds[i]) + 1];
m_CellEulerAngles[3 * i + 2] = m_FeatureEulerAngles[3 * (m_FeatureIds[i]) + 2];
}
QuatF* avgQuats = reinterpret_cast<QuatF*>(m_AvgQuats);
for (int32_t i = 1; i < totalFeatures; i++)
{
FOrientArrayType quat(4, 0.0);
FOrientTransformsType::eu2qu(FOrientArrayType(&(m_FeatureEulerAngles[3 * i]), 3), quat);
QuaternionMathF::Copy(quat.toQuaternion(), avgQuats[i]);
}
// If there is an error set this to something negative and also set a message
notifyStatusMessage(getHumanLabel(), "Complete");
}
Generator getUniformGenerator(const float rangeMin, const float rangeMax) {
NumberDistribution distribution( rangeMin, rangeMax );
Generator numberGenerator(generator, distribution);
return numberGenerator;
}
DummyGeneratorPlugin::DummyGeneratorPlugin()
{
m_extensions.push_back(new plugin::Extension(numberGenerator()));
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void MergeColonies::execute()
{
setErrorCondition(0);
dataCheck();
if(getErrorCondition() < 0) { return; }
axisTolerance = m_AxisTolerance * SIMPLib::Constants::k_Pi / 180.0f;
GroupFeatures::execute();
size_t totalFeatures = m_ActivePtr.lock()->getNumberOfTuples();
if (totalFeatures < 2)
{
setErrorCondition(-87000);
notifyErrorMessage(getHumanLabel(), "The number of Grouped Features was 0 or 1 which means no grouped Features were detected. A grouping value may be set too high", getErrorCondition());
return;
}
int32_t numParents = 0;
size_t totalPoints = m_FeatureIdsPtr.lock()->getNumberOfTuples();
for (size_t k = 0; k < totalPoints; k++)
{
int32_t featurename = m_FeatureIds[k];
m_CellParentIds[k] = m_FeatureParentIds[featurename];
if (m_FeatureParentIds[featurename] > numParents) { numParents = m_FeatureParentIds[featurename]; }
}
numParents += 1;
notifyStatusMessage(getHumanLabel(), "Characterizing Colonies");
characterize_colonies();
if (true == m_RandomizeParentIds)
{
// Generate all the numbers up front
const int32_t rangeMin = 1;
const int32_t rangeMax = numParents - 1;
typedef boost::uniform_int<int32_t> NumberDistribution;
typedef boost::mt19937 RandomNumberGenerator;
typedef boost::variate_generator < RandomNumberGenerator&,
NumberDistribution > Generator;
NumberDistribution distribution(rangeMin, rangeMax);
RandomNumberGenerator generator;
Generator numberGenerator(generator, distribution);
generator.seed(static_cast<boost::uint32_t>( QDateTime::currentMSecsSinceEpoch() )); // seed with the current time
DataArray<int32_t>::Pointer rndNumbers = DataArray<int32_t>::CreateArray(numParents, "_INTERNAL_USE_ONLY_NewParentIds");
int32_t* pid = rndNumbers->getPointer(0);
pid[0] = 0;
QSet<int32_t> parentIdSet;
parentIdSet.insert(0);
for (int32_t i = 1; i < numParents; ++i)
{
pid[i] = i; // numberGenerator();
parentIdSet.insert(pid[i]);
}
int32_t r = 0;
int32_t temp = 0;
//--- Shuffle elements by randomly exchanging each with one other.
for (int32_t i = 1; i < numParents; i++)
{
r = numberGenerator(); // Random remaining position.
if (r >= numParents)
{
continue;
}
temp = pid[i];
pid[i] = pid[r];
pid[r] = temp;
}
// Now adjust all the Feature Id values for each Voxel
for (size_t i = 0; i < totalPoints; ++i)
{
m_CellParentIds[i] = pid[ m_CellParentIds[i] ];
m_FeatureParentIds[m_FeatureIds[i]] = m_CellParentIds[i];
}
}
if (m_IdentifyGlobAlpha == true)
{
identify_globAlpha();
}
notifyStatusMessage(getHumanLabel(), "Complete");
}
