void DataPartitions::doFrequency(DoubleVector dimData){
m_partitions.clear();
PairVector dimOrData;
initPairs(dimOrData, dimData);
pairSort(dimOrData);
int dimsize = dimData.size();
int nBins = this->m_rddtClust->m_rddtOp->m_nBins;
if(nBins == 0 ){
nBins = 1;
}
if(nBins>dimsize){
nBins = dimsize;
}
for(int i = 0; i< nBins; i++){
DataPartition* partition = new DataPartition();
partition->setPartitions(this);
partition->m_partitionIdx = i;
this->m_partitions.push_back(partition);
}
int partitionsize = (int)ceil((double)dimsize/(double)nBins);
for(unsigned i = 0; i< dimOrData.size(); i++){
int p = (int)((double)i/(double)partitionsize);
if(p>(int)m_partitions.size())
p=m_partitions.size();
int first = (dimOrData[i]).first;
(m_partitions[p])->m_parIndices.push_back(first);
}
}
void Transformed::divideTools(const std::vector<TopoDS_Shape> &toolsIn, std::vector<TopoDS_Shape> &individualsOut,
TopoDS_Compound &compoundOut) const
{
typedef std::pair<TopoDS_Shape, Bnd_Box> ShapeBoundPair;
typedef std::list<ShapeBoundPair> PairList;
typedef std::vector<ShapeBoundPair> PairVector;
PairList pairList;
std::vector<TopoDS_Shape>::const_iterator it;
for (it = toolsIn.begin(); it != toolsIn.end(); ++it)
{
Bnd_Box bound;
BRepBndLib::Add(*it, bound);
bound.SetGap(0.0);
ShapeBoundPair temp = std::make_pair(*it, bound);
pairList.push_back(temp);
}
BRep_Builder builder;
builder.MakeCompound(compoundOut);
while(!pairList.empty())
{
PairVector currentGroup;
currentGroup.push_back(pairList.front());
pairList.pop_front();
PairList::iterator it = pairList.begin();
while(it != pairList.end())
{
PairVector::const_iterator groupIt;
bool found(false);
for (groupIt = currentGroup.begin(); groupIt != currentGroup.end(); ++groupIt)
{
if (!(*it).second.IsOut((*groupIt).second))//touching means is out.
{
found = true;
break;
}
}
if (found)
{
currentGroup.push_back(*it);
pairList.erase(it);
it=pairList.begin();
continue;
}
it++;
}
if (currentGroup.size() == 1)
builder.Add(compoundOut, currentGroup.front().first);
else
{
PairVector::const_iterator groupIt;
for (groupIt = currentGroup.begin(); groupIt != currentGroup.end(); ++groupIt)
individualsOut.push_back((*groupIt).first);
}
}
}
void UCK::makePathMatrix(const PairVector& e, SizeVector& sp, const Size e_size)
{
std::vector<Size>* line;
// create bond-matrix, because Floyd's Algorithm requires a reachability matrix
SizeVector* bond_matrix;
line = new vector<Size>;
bond_matrix = new SizeVector;
// initialize bond-matrix with 0 at every position
for (Size i = 0; i != e_size; ++i)
{
line->clear();
for(Size j = 0; j != e_size; ++j)
{
line->push_back(0);
}
bond_matrix->push_back(*line);
}
// proceed all edges and set corresponding position in bond_matrix to 1
for (Size i = 0; i != e.size(); ++i)
{
(*bond_matrix)[e[i].first][e[i].second] = 1;
}
// initialize sp-matrix
for(Size i = 0; i != bond_matrix->size(); ++i)
{
line->clear();
for(Size j = 0; j != bond_matrix->size(); ++j)
{
if (i == j) // distance from a node to itself = 0
{
line->push_back(0);
}
else if((*bond_matrix)[i][j] == 1) // if an edge exists between node i and j,
{
line->push_back(1); // the distance between them is 1
}
else
{
line->push_back(std::numeric_limits<Index>::max()); // otherwise the distance is set to infinity
}
}
sp.push_back(*line);
}
// Floyd's Algorithm
for(Size i = 0; i != sp.size(); ++i)
{
for(Size j = 0; j != sp.size(); ++j)
{
for(Size k = 0; k != sp.size(); k++)
{
if(sp[j][k] > (sp[j][i] + sp[i][k]))
{
sp[j][k] = (sp[j][i] + sp[i][k]);
}
}
}
}
delete bond_matrix;
delete line;
return;
}
