CosineTree::CosineTree(CosineTree& parentNode,
const std::vector<size_t>& subIndices) :
dataset(parentNode.GetDataset()),
parent(&parentNode),
left(NULL),
right(NULL),
numColumns(subIndices.size())
{
// Initialize sizes of column indices and l2 norms.
indices.resize(numColumns);
l2NormsSquared.zeros(numColumns);
// Set indices and squared norms of the columns.
for (size_t i = 0; i < numColumns; i++)
{
indices[i] = parentNode.indices[subIndices[i]];
l2NormsSquared(i) = parentNode.l2NormsSquared(subIndices[i]);
}
// Frobenius norm of columns in the node.
frobNormSquared = arma::accu(l2NormsSquared);
// Calculate centroid of columns in the node.
CalculateCentroid();
splitPointIndex = ColumnSampleLS();
}
CosineTree::CosineTree(const arma::mat& dataset) :
dataset(dataset),
parent(NULL),
left(NULL),
right(NULL),
numColumns(dataset.n_cols)
{
// Initialize sizes of column indices and l2 norms.
indices.resize(numColumns);
l2NormsSquared.zeros(numColumns);
// Set indices and calculate squared norms of the columns.
for (size_t i = 0; i < numColumns; i++)
{
indices[i] = i;
double l2Norm = arma::norm(dataset.col(i), 2);
l2NormsSquared(i) = l2Norm * l2Norm;
}
// Frobenius norm of columns in the node.
frobNormSquared = arma::accu(l2NormsSquared);
// Calculate centroid of columns in the node.
CalculateCentroid();
splitPointIndex = ColumnSampleLS();
}
void CosineTreeBuilder::CTNode(arma::mat A, CosineTree& root)
{
A = A.t();
Log::Info<<"CTNode"<<std::endl;
//Calculating Centroid
arma::rowvec centroid = CalculateCentroid(A);
//Calculating sampling probabilities
arma::vec probabilities = arma::zeros<arma::vec>(A.n_rows,1);
LSSampling(A,probabilities);
//Setting Values
root.Probabilities(probabilities);
root.Data(A);
root.Centroid(centroid);
}
void Polygon::CreateConvexPolygon(std::vector<sf::Vector2f> points, sf::Color color)
{
//Get number of points
m_shape.setPointCount(points.size());
//Set points to SFML shape
for (int i = 0; i < points.size(); ++i)
m_shape.setPoint(i, points[i]);
//Set the fill color
m_shape.setFillColor(color);
//Set centroid to origin
CalculateCentroid();
}
Centroid* ClusterDist_SRMSD::NewCentroid( Cframes const& cframesIn ) {
// TODO: Incorporate mass?
Centroid_Coord* cent = new Centroid_Coord( mask_.Nselected() );
CalculateCentroid( cent, cframesIn );
return cent;
}
Centroid* ClusterDist_Euclid::NewCentroid(Cframes const& cframesIn) {
Centroid_Multi* cent = new Centroid_Multi();
CalculateCentroid(cent, cframesIn);
return cent;
}
/** \return A new centroid of the given frames. */
Centroid* ClusterDist_Num::NewCentroid( Cframes const& cframesIn ) {
Centroid_Num* cent = new Centroid_Num();
CalculateCentroid( cent, cframesIn );
return cent;
}
inline void MeanShift<UseKernel, KernelType, MatType>::Cluster(
const MatType& data,
arma::Col<size_t>& assignments,
arma::mat& centroids,
bool useSeeds)
{
if (radius <= 0)
{
// An invalid radius is given; an estimation is needed.
Radius(EstimateRadius(data));
}
MatType seeds;
const MatType* pSeeds = &data;
if (useSeeds)
{
GenSeeds(data, radius, 1, seeds);
pSeeds = &seeds;
}
// Holds all centroids before removing duplicate ones.
arma::mat allCentroids(pSeeds->n_rows, pSeeds->n_cols);
assignments.set_size(data.n_cols);
range::RangeSearch<> rangeSearcher(data);
math::Range validRadius(0, radius);
std::vector<std::vector<size_t> > neighbors;
std::vector<std::vector<double> > distances;
// For each seed, perform mean shift algorithm.
for (size_t i = 0; i < pSeeds->n_cols; ++i)
{
// Initial centroid is the seed itself.
allCentroids.col(i) = pSeeds->unsafe_col(i);
for (size_t completedIterations = 0; completedIterations < maxIterations;
completedIterations++)
{
// Store new centroid in this.
arma::colvec newCentroid = arma::zeros<arma::colvec>(pSeeds->n_rows);
rangeSearcher.Search(allCentroids.unsafe_col(i), validRadius,
neighbors, distances);
if (neighbors[0].size() <= 1)
break;
// Calculate new centroid.
if (!CalculateCentroid(data, neighbors[0], distances[0], newCentroid))
newCentroid = allCentroids.unsafe_col(i);
// If the mean shift vector is small enough, it has converged.
if (metric::EuclideanDistance::Evaluate(newCentroid,
allCentroids.unsafe_col(i)) < 1e-3 * radius)
{
// Determine if the new centroid is duplicate with old ones.
bool isDuplicated = false;
for (size_t k = 0; k < centroids.n_cols; ++k)
{
const double distance = metric::EuclideanDistance::Evaluate(
allCentroids.unsafe_col(i), centroids.unsafe_col(k));
if (distance < radius)
{
isDuplicated = true;
break;
}
}
if (!isDuplicated)
centroids.insert_cols(centroids.n_cols, allCentroids.unsafe_col(i));
// Get out of the loop.
break;
}
// Update the centroid.
allCentroids.col(i) = newCentroid;
}
}
// Assign centroids to each point.
neighbor::KNN neighborSearcher(centroids);
arma::mat neighborDistances;
arma::Mat<size_t> resultingNeighbors;
neighborSearcher.Search(data, 1, resultingNeighbors, neighborDistances);
assignments = resultingNeighbors.t();
}