void cls_lbgu::start() {
double best_ssq;
std::vector<cls_cluster*> best_clusters;
init_random_clusters();
assign_points();
best_clusters = copy_clusters(m_clusters);
best_ssq = get_global_ssq();
while (true) {
start_one_iteration_analysis();
double ssq = get_global_ssq();
if (ssq >= best_ssq)
break;
best_ssq = ssq;
best_clusters = copy_clusters(m_clusters);
double min_us = std::numeric_limits<double>::max();
double max_er = std::numeric_limits<double>::min();
cls_cluster *c_min_us = NULL;
cls_cluster *c_max_er = NULL;
for (int i = 0; i < m_k; i++) {
cls_cluster *act_cluster = m_clusters[i];
double us = get_usability(act_cluster);
double er = get_local_ssq(act_cluster);
if (us < min_us) {
min_us = us;
c_min_us = act_cluster;
}
if (er > max_er) {
max_er = er;
c_max_er = act_cluster;
}
}
for (int i = 0; i < c_min_us->get_dimension(); i++) {
double r = cls_random::get_shared_instance()->next_gaussian();
double coord = c_max_er->get_coordinate(i);
coord += 0.001 * r * sqrt(max_er / m_points.size());
c_min_us->set_coordinate(coord, i);
}
assign_points();
}
m_clusters = best_clusters;
for (int i = 0; i < m_k; i++)
m_clusters[i]->set_assigned_points(std::vector<cls_point*>());
for (int i = 0; i < (int) m_points.size(); i++)
m_points[i]->set_assigned_cluster(NULL);
assign_points();
}
void cls_lbgu::init_random_clusters() {
cls_random *rand = cls_random::get_shared_instance();
std::vector<int> numbers = std::vector<int>(m_k);
for (int i = 0; i < m_k; i++)
numbers[i] = -1;
for (int i = 0; i < m_k; i++) {
bool stop;
int r = 0;
do {
stop = true;
r = rand->next_int(0, m_points.size());
for (int j = 0; j < i; j++) {
if (numbers[j] == r) {
stop = false;
break;
}
}
} while (!stop);
numbers[i] = r;
cls_cluster *new_cluster = new cls_cluster(m_points[r]->get_coordinates());
m_clusters.push_back(new_cluster);
}
assign_points();
}
void cls_lbgu::start_one_iteration_analysis() {
bool change = true;
while (change) {
for (int i = 0; i < m_k; i++)
m_clusters[i]->calculate_mean_point();
change = assign_points();
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void InsertAtoms::execute()
{
setErrorCondition(0);
dataCheck();
if(getErrorCondition() < 0) { return; }
// Validate that the selected AvgQuats array has tuples equal to the largest
// Feature Id; the filter would not crash otherwise, but the user should
// be notified of unanticipated behavior ; this cannot be done in the dataCheck since
// we don't have acces to the data yet
int32_t numFeaturesIn = static_cast<int32_t>(m_AvgQuatsPtr.lock()->getNumberOfTuples());
bool mismatchedFeatures = true;
int32_t largestFeature = 0;
size_t numTuples = m_SurfaceMeshFaceLabelsPtr.lock()->getNumberOfTuples();
for (size_t i = 0; i < numTuples; i++)
{
if (m_SurfaceMeshFaceLabels[2 * i] > largestFeature)
{
largestFeature = m_SurfaceMeshFaceLabels[2 * i];
if (largestFeature >= numFeaturesIn)
{
mismatchedFeatures = true;
break;
}
}
else if (m_SurfaceMeshFaceLabels[2 * i + 1] > largestFeature)
{
largestFeature = m_SurfaceMeshFaceLabels[2 * i + 1];
if (largestFeature >= numFeaturesIn)
{
mismatchedFeatures = true;
break;
}
}
}
if (mismatchedFeatures == true)
{
QString ss = QObject::tr("The number of Features in the AvgQuats array (%1) is larger than the largest Feature Id in the SurfaceMeshFaceLabels array").arg(numFeaturesIn);
setErrorCondition(-5555);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
if (largestFeature != (numFeaturesIn - 1))
{
QString ss = QObject::tr("The number of Features in the AvgQuats array (%1) does not match the largest Feature Id in the SurfaceMeshFaceLabels array").arg(numFeaturesIn);
setErrorCondition(-5555);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
FloatVec3_t latticeConstants;
latticeConstants.x = m_LatticeConstants.x / 10000.0;
latticeConstants.y = m_LatticeConstants.y / 10000.0;
latticeConstants.z = m_LatticeConstants.z / 10000.0;
DataContainer::Pointer sm = getDataContainerArray()->getDataContainer(getSurfaceMeshFaceLabelsArrayPath().getDataContainerName());
SIMPL_RANDOMNG_NEW()
#ifdef SIMPLib_USE_PARALLEL_ALGORITHMS
tbb::task_scheduler_init init;
bool doParallel = true;
#endif
// pull down faces
TriangleGeom::Pointer triangleGeom = sm->getGeometryAs<TriangleGeom>();
int64_t numFaces = m_SurfaceMeshFaceLabelsPtr.lock()->getNumberOfTuples();
// create array to hold bounding vertices for each face
FloatArrayType::Pointer llPtr = FloatArrayType::CreateArray(3, "Lower_Left_Internal_Use_Only");
FloatArrayType::Pointer urPtr = FloatArrayType::CreateArray(3, "Upper_Right_Internal_Use_Only");
float* ll = llPtr->getPointer(0);
float* ur = urPtr->getPointer(0);
VertexGeom::Pointer faceBBs = VertexGeom::CreateGeometry(2 * numFaces, "faceBBs");
// walk through faces to see how many features there are
int32_t g1 = 0, g2 = 0;
int32_t maxFeatureId = 0;
for (int64_t i = 0; i < numFaces; i++)
{
g1 = m_SurfaceMeshFaceLabels[2 * i];
g2 = m_SurfaceMeshFaceLabels[2 * i + 1];
if (g1 > maxFeatureId) { maxFeatureId = g1; }
if (g2 > maxFeatureId) { maxFeatureId = g2; }
}
// add one to account for feature 0
int32_t numFeatures = maxFeatureId + 1;
// create a dynamic list array to hold face lists
Int32Int32DynamicListArray::Pointer faceLists = Int32Int32DynamicListArray::New();
QVector<int32_t> linkCount(numFeatures, 0);
// fill out lists with number of references to cells
typedef boost::shared_array<int32_t> SharedInt32Array_t;
SharedInt32Array_t linkLocPtr(new int32_t[numFaces]);
int32_t* linkLoc = linkLocPtr.get();
::memset(linkLoc, 0, numFaces * sizeof(int32_t));
// traverse data to determine number of faces belonging to each feature
for (int64_t i = 0; i < numFaces; i++)
{
g1 = m_SurfaceMeshFaceLabels[2 * i];
g2 = m_SurfaceMeshFaceLabels[2 * i + 1];
if (g1 > 0) { linkCount[g1]++; }
if (g2 > 0) { linkCount[g2]++; }
}
// now allocate storage for the faces
faceLists->allocateLists(linkCount);
// traverse data again to get the faces belonging to each feature
for (int64_t i = 0; i < numFaces; i++)
{
g1 = m_SurfaceMeshFaceLabels[2 * i];
g2 = m_SurfaceMeshFaceLabels[2 * i + 1];
if (g1 > 0) { faceLists->insertCellReference(g1, (linkLoc[g1])++, i); }
if (g2 > 0) { faceLists->insertCellReference(g2, (linkLoc[g2])++, i); }
// find bounding box for each face
GeometryMath::FindBoundingBoxOfFace(triangleGeom, i, ll, ur);
faceBBs->setCoords(2 * i, ll);
faceBBs->setCoords(2 * i + 1, ur);
}
// generate the list of sampling points fom subclass
QVector<VertexGeom::Pointer> points(numFeatures);
QVector<BoolArrayType::Pointer> inFeature(numFeatures);
for (int32_t i = 0; i < numFeatures; i++)
{
points[i] = VertexGeom::CreateGeometry(0, "_INTERNAL_USE_ONLY_points");
inFeature[i] = BoolArrayType::CreateArray(0, "_INTERNAL_USE_ONLY_inside");
}
QuatF* avgQuats = reinterpret_cast<QuatF*>(m_AvgQuats);
#ifdef SIMPLib_USE_PARALLEL_ALGORITHMS
if (doParallel == true)
{
tbb::parallel_for(tbb::blocked_range<size_t>(0, numFeatures),
InsertAtomsImpl(triangleGeom, faceLists, faceBBs, avgQuats, latticeConstants, m_Basis, points, inFeature), tbb::auto_partitioner());
}
else
#endif
{
InsertAtomsImpl serial(triangleGeom, faceLists, faceBBs, avgQuats, latticeConstants, m_Basis, points, inFeature);
serial.checkPoints(0, numFeatures);
}
assign_points(points, inFeature);
notifyStatusMessage(getHumanLabel(), "Complete");
}
void CentroidsAssignment::operator()(std::vector<unsigned int> &assignment) {
assign_points(assignment, m_centroids, m_points);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void SampleSurfaceMesh::execute()
{
setErrorCondition(0);
dataCheck();
if(getErrorCondition() < 0) { return; }
DataContainer::Pointer sm = getDataContainerArray()->getDataContainer(m_SurfaceMeshFaceLabelsArrayPath.getDataContainerName());
SIMPL_RANDOMNG_NEW()
#ifdef SIMPLib_USE_PARALLEL_ALGORITHMS
tbb::task_scheduler_init init;
bool doParallel = true;
#endif
TriangleGeom::Pointer triangleGeom = sm->getGeometryAs<TriangleGeom>();
// pull down faces
int64_t numFaces = m_SurfaceMeshFaceLabelsPtr.lock()->getNumberOfTuples();
// create array to hold bounding vertices for each face
FloatArrayType::Pointer llPtr = FloatArrayType::CreateArray(3, "_INTERNAL_USE_ONLY_Lower_Left");
FloatArrayType::Pointer urPtr = FloatArrayType::CreateArray(3, "_INTERNAL_USE_ONLY_Upper_Right");
float* ll = llPtr->getPointer(0);
float* ur = urPtr->getPointer(0);
VertexGeom::Pointer faceBBs = VertexGeom::CreateGeometry(2 * numFaces, "_INTERNAL_USE_ONLY_faceBBs");
// walk through faces to see how many features there are
int32_t g1 = 0, g2 = 0;
int32_t maxFeatureId = 0;
for (int64_t i = 0; i < numFaces; i++)
{
g1 = m_SurfaceMeshFaceLabels[2 * i];
g2 = m_SurfaceMeshFaceLabels[2 * i + 1];
if (g1 > maxFeatureId) { maxFeatureId = g1; }
if (g2 > maxFeatureId) { maxFeatureId = g2; }
}
// add one to account for feature 0
int32_t numFeatures = maxFeatureId + 1;
// create a dynamic list array to hold face lists
Int32Int32DynamicListArray::Pointer faceLists = Int32Int32DynamicListArray::New();
std::vector<int32_t> linkCount(numFeatures, 0);
// fill out lists with number of references to cells
typedef boost::shared_array<int32_t> SharedInt32Array_t;
SharedInt32Array_t linkLocPtr(new int32_t[numFaces]);
int32_t* linkLoc = linkLocPtr.get();
::memset(linkLoc, 0, numFaces * sizeof(int32_t));
// traverse data to determine number of faces belonging to each feature
for (int64_t i = 0; i < numFaces; i++)
{
g1 = m_SurfaceMeshFaceLabels[2 * i];
g2 = m_SurfaceMeshFaceLabels[2 * i + 1];
if (g1 > 0) { linkCount[g1]++; }
if (g2 > 0) { linkCount[g2]++; }
}
// now allocate storage for the faces
faceLists->allocateLists(linkCount);
// traverse data again to get the faces belonging to each feature
for (int64_t i = 0; i < numFaces; i++)
{
g1 = m_SurfaceMeshFaceLabels[2 * i];
g2 = m_SurfaceMeshFaceLabels[2 * i + 1];
if (g1 > 0) { faceLists->insertCellReference(g1, (linkLoc[g1])++, i); }
if (g2 > 0) { faceLists->insertCellReference(g2, (linkLoc[g2])++, i); }
// find bounding box for each face
GeometryMath::FindBoundingBoxOfFace(triangleGeom, i, ll, ur);
faceBBs->setCoords(2 * i, ll);
faceBBs->setCoords(2 * i + 1, ur);
}
// generate the list of sampling points from subclass
VertexGeom::Pointer points = generate_points();
if(getErrorCondition() < 0 || NULL == points.get()) { return; }
int64_t numPoints = points->getNumberOfVertices();
// create array to hold which polyhedron (feature) each point falls in
Int32ArrayType::Pointer iArray = Int32ArrayType::NullPointer();
iArray = Int32ArrayType::CreateArray(numPoints, "_INTERNAL_USE_ONLY_polyhedronIds");
iArray->initializeWithZeros();
int32_t* polyIds = iArray->getPointer(0);
#ifdef SIMPLib_USE_PARALLEL_ALGORITHMS
if (doParallel == true)
{
tbb::parallel_for(tbb::blocked_range<size_t>(0, numFeatures),
SampleSurfaceMeshImpl(triangleGeom, faceLists, faceBBs, points, polyIds), tbb::auto_partitioner());
}
else
#endif
{
SampleSurfaceMeshImpl serial(triangleGeom, faceLists, faceBBs, points, polyIds);
serial.checkPoints(0, numFeatures);
}
assign_points(iArray);
notifyStatusMessage(getHumanLabel(), "Complete");
}
