void AverageLinkage::operator()(DistanceMatrix<float> & original_distance, std::vector<BinaryTreeNode> & cluster_tree, const float threshold /*=1*/) const
{
// input MUST have >= 2 elements!
if (original_distance.dimensionsize() < 2)
{
throw ClusterFunctor::InsufficientInput(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, "Distance matrix to start from only contains one element");
}
std::vector<std::set<Size> > clusters(original_distance.dimensionsize());
for (Size i = 0; i < original_distance.dimensionsize(); ++i)
{
clusters[i].insert(i);
}
cluster_tree.clear();
cluster_tree.reserve(original_distance.dimensionsize() - 1);
// Initial minimum-distance pair
original_distance.updateMinElement();
std::pair<Size, Size> min = original_distance.getMinElementCoordinates();
Size overall_cluster_steps(original_distance.dimensionsize());
startProgress(0, original_distance.dimensionsize(), "clustering data");
while (original_distance(min.second, min.first) < threshold)
{
//grow the tree
cluster_tree.push_back(BinaryTreeNode(*(clusters[min.second].begin()), *(clusters[min.first].begin()), original_distance(min.first, min.second)));
if (cluster_tree.back().left_child > cluster_tree.back().right_child)
{
std::swap(cluster_tree.back().left_child, cluster_tree.back().right_child);
}
if (original_distance.dimensionsize() > 2)
{
//pick minimum-distance pair i,j and merge them
//calculate parameter for lance-williams formula
float alpha_i = (float)(clusters[min.first].size() / (float)(clusters[min.first].size() + clusters[min.second].size()));
float alpha_j = (float)(clusters[min.second].size() / (float)(clusters[min.first].size() + clusters[min.second].size()));
//~ std::cout << alpha_i << '\t' << alpha_j << std::endl;
//pushback elements of second to first (and then erase second)
clusters[min.second].insert(clusters[min.first].begin(), clusters[min.first].end());
// erase first one
clusters.erase(clusters.begin() + min.first);
//update original_distance matrix
//average linkage: new distance between clusters is the minimum distance between elements of each cluster
//lance-williams update for d((i,j),k): (m_i/m_i+m_j)* d(i,k) + (m_j/m_i+m_j)* d(j,k) ; m_x is the number of elements in cluster x
for (Size k = 0; k < min.second; ++k)
{
float dik = original_distance.getValue(min.first, k);
float djk = original_distance.getValue(min.second, k);
original_distance.setValueQuick(min.second, k, (alpha_i * dik + alpha_j * djk));
}
for (Size k = min.second + 1; k < original_distance.dimensionsize(); ++k)
{
float dik = original_distance.getValue(min.first, k);
float djk = original_distance.getValue(min.second, k);
original_distance.setValueQuick(k, min.second, (alpha_i * dik + alpha_j * djk));
}
//reduce
original_distance.reduce(min.first);
//update minimum-distance pair
original_distance.updateMinElement();
//get min-pair from triangular matrix
min = original_distance.getMinElementCoordinates();
}
else
{
break;
}
setProgress(overall_cluster_steps - original_distance.dimensionsize());
//repeat until only two cluster remains, last step skips matrix operations
}
//fill tree with dummy nodes
Size sad(*clusters.front().begin());
for (Size i = 1; (i < clusters.size()) && (cluster_tree.size() < cluster_tree.capacity()); ++i)
{
cluster_tree.push_back(BinaryTreeNode(sad, *clusters[i].begin(), -1.0));
}
endProgress();
}
inline iMesh::Error
iMesh::getAdjEntIndices( EntitySetHandle set,
EntityType requestor_type,
EntityTopology requestor_topo,
EntityType type_requested,
std::vector<EntityHandle>& entities_out,
std::vector<EntityHandle>& adj_entities_out,
std::vector<int>& adj_indices_out,
std::vector<int>& offsets_out ) const
{
// if input vects have no allocated space, allocate some so
// we don't accidentally ask the impl to allocate an array
if (entities_out.capacity() == 0) {
Error err2;
int count;
if (requestor_topo == iMesh_ALL_TOPOLOGIES)
err2 = getNumOfType( set, requestor_type, count );
else
err2 = getNumOfTopo( set, requestor_topo, count );
if (err2 != iBase_SUCCESS)
return err2;
entities_out.resize( count );
}
else
entities_out.resize( entities_out.capacity() );
if (adj_entities_out.capacity() == 0)
adj_entities_out.resize( 12*entities_out.size() );
else
adj_entities_out.resize( adj_entities_out.capacity() );
if (adj_indices_out.capacity() == 0)
adj_indices_out.resize( 12*entities_out.size() );
else
adj_indices_out.resize( adj_indices_out.capacity() );
if (offsets_out.capacity() == 0)
offsets_out.resize( entities_out.size() + 1 );
else
offsets_out.resize( offsets_out.capacity() );
int err;
int entities_size = 0, entities_alloc = entities_out.size();
int adj_entities_size = 0, adj_entities_alloc = adj_entities_out.size();
int adj_indices_size = 0, adj_indices_alloc = adj_indices_out.size();
int offsets_size = 0, offsets_alloc = offsets_out.size();
EntityHandle* entities_ptr = & entities_out[0];
EntityHandle* adj_entities_ptr = &adj_entities_out[0];
int * adj_indices_ptr = & adj_indices_out[0];
int * offsets_ptr = & offsets_out[0];
iMesh_getAdjEntIndices( mInstance,
set, requestor_type, requestor_topo,
type_requested,
& entities_ptr, & entities_alloc, & entities_size,
&adj_entities_ptr, &adj_entities_alloc, &adj_entities_size,
& adj_indices_ptr, & adj_indices_alloc, & adj_indices_size,
& offsets_ptr, & offsets_alloc, & offsets_size,
&err );
entities_out.resize( entities_size );
adj_entities_out.resize( adj_entities_size );
adj_indices_out.resize( adj_indices_size );
offsets_out.resize( offsets_size );
if (iBase_BAD_ARRAY_DIMENSION == err || iBase_BAD_ARRAY_SIZE == err) {
entities_alloc = entities_out.size();
adj_entities_alloc = adj_entities_out.size();
adj_indices_alloc = adj_indices_out.size();
offsets_alloc = offsets_out.size();
entities_ptr = & entities_out[0];
adj_entities_ptr = &adj_entities_out[0];
adj_indices_ptr = & adj_indices_out[0];
offsets_ptr = & offsets_out[0];
iMesh_getAdjEntIndices( mInstance,
set, requestor_type, requestor_topo,
type_requested,
& entities_ptr, & entities_alloc, & entities_size,
&adj_entities_ptr, &adj_entities_alloc, &adj_entities_size,
& adj_indices_ptr, & adj_indices_alloc, & adj_indices_size,
& offsets_ptr, & offsets_alloc, & offsets_size,
&err );
}
return (Error)err;
}
uint8_t ucp::pop_RxdQue_()
{
static std::vector<char> temp;
uint16_t tempsize = temp.size();
#if 1
if (ucp_Usart.Get_cbInQue() > 0)
{
temp.resize(tempsize + Usart_->Get_cbInQue(), 0);
ucp_Usart.PopRxdQueue(&(temp[0]) + tempsize);
}
#else
if (Usart_->Get_cbInQue() > 0)
{
//temp.resize(tempsize + Usart_->Get_cbInQue(), 0);
//Usart_->PopRxdQueue(&(temp[0]) + tempsize);
Usart_->PopRxdQueue((char*)RxdBuf_);
for (int i = 0; i < min(test, 20); i++)
{
std::cout << std::hex << (uint16_t)(uint8_t)RxdBuf_[i] << " ";
}
std::cout << std::endl;
}
#endif
RxdPkgTyp tempPack;
if (temp.size() < sizeof(tempPack))
return 0;
while (true)
{
if ((uint8_t)temp[0] == 0x55 &&
(uint8_t)temp[1] == 0xAA &&
(uint8_t)temp[sizeof(tempPack)-1] == 0x00)
{
/* copy full pack data */
for (uint16_t i = 0; i < sizeof(tempPack); i++)
{
((uint8_t*)&tempPack)[i] = temp[i];
}
temp.erase(temp.begin(), temp.begin() + sizeof(tempPack) - 1);
/* execute */
Registry_[tempPack.DataIdx]->set(tempPack.Data);
}
if (temp.size() <= sizeof(tempPack))
{
break;
// unpack finished
}
temp.erase(temp.begin()); // pop front
}
if (temp.capacity() > 1)
{
std::vector<char> rls = temp; //release the memory that allocated by temp
temp.swap(rls);
#if 0
if (temp.size() > 0)
{
std::cout << (int)&temp[0] << std::endl;
}
#endif
}
return 1;
}
bool GetFileString::GetTString(std::vector<T>& From, std::vector<T>& To, bool bBigEndian)
{
typedef eol<T> eol;
bool ExitCode = true;
T* ReadBufPtr = ReadPos < ReadSize ? From.data() + ReadPos / sizeof(T) : nullptr;
To.clear();
// Обработка ситуации, когда у нас пришёл двойной \r\r, а потом не было \n.
// В этом случаем считаем \r\r двумя MAC окончаниями строк.
if (bCrCr)
{
To.emplace_back(T(eol::cr));
bCrCr = false;
}
else
{
EolType Eol = FEOL_NONE;
for (;;)
{
if (ReadPos >= ReadSize)
{
if (!(SrcFile.Read(From.data(), ReadBufCount*sizeof(T), ReadSize) && ReadSize))
{
if (To.empty())
{
ExitCode = false;
}
break;
}
if (bBigEndian && sizeof(T) != 1)
{
_swab(reinterpret_cast<char*>(From.data()), reinterpret_cast<char*>(From.data()), ReadSize);
}
ReadPos = 0;
ReadBufPtr = From.data();
}
if (Eol == FEOL_NONE)
{
// UNIX
if (*ReadBufPtr == eol::lf)
{
Eol = FEOL_UNIX;
}
// MAC / Windows? / Notepad?
else if (*ReadBufPtr == eol::cr)
{
Eol = FEOL_MAC;
}
}
else if (Eol == FEOL_MAC)
{
// Windows
if (*ReadBufPtr == eol::lf)
{
Eol = FEOL_WINDOWS;
}
// Notepad?
else if (*ReadBufPtr == eol::cr)
{
Eol = FEOL_MAC2;
}
else
{
break;
}
}
else if (Eol == FEOL_WINDOWS || Eol == FEOL_UNIX)
{
break;
}
else if (Eol == FEOL_MAC2)
{
// Notepad
if (*ReadBufPtr == eol::lf)
{
Eol = FEOL_NOTEPAD;
}
else
{
// Пришёл \r\r, а \n не пришёл, поэтому считаем \r\r двумя MAC окончаниями строк
To.pop_back();
bCrCr = true;
break;
}
}
else
{
break;
}
ReadPos += sizeof(T);
if (To.size() == To.capacity())
To.reserve(To.size() * 2);
To.emplace_back(*ReadBufPtr);
ReadBufPtr++;
}
}
To.push_back(0);
return ExitCode;
}
int32_t BucketElimination::Bucket::CreateMBPartitioning(int32_t iBound, bool CreateTables, bool doMomentMatching, bool & AbandonIfActualPartitioning, std::vector<int32_t> & key, std::vector<int64_t> & data, std::vector<int32_t> & helperArray)
{
bool abandonIfActualPartitioning = AbandonIfActualPartitioning ;
AbandonIfActualPartitioning = false ;
//INT64 tB = ARE::GetTimeInMilliseconds() ;
// sort functions in the order of decreasing scope size
int32_t nF = nOriginalFunctions() + nAugmentedFunctions() ;
if (key.capacity() < nF) { key.reserve(nF) ; if (key.capacity() < nF) goto failed ; }
if (data.capacity() < nF) { data.reserve(nF) ; if (data.capacity() < nF) goto failed ; }
key.clear() ; data.clear() ;
for (int32_t j = _nOriginalFunctions - 1 ; j >= 0 ; j--) {
ARE::Function *f = _OriginalFunctions[j] ;
key.push_back(-f->N()) ;
data.push_back((INT64) f) ;
if (data.size() != key.size()) {
fprintf(ARE::fpLOG, "\n BucketElimination::Bucket::CreateMBPartitioning ERROR : data_size!=key_size(1); i=%d, v=%d, nMBs=%d", (int32_t) _IDX, (int32_t) _V, (int32_t) _MiniBuckets.size()) ;
::fflush(ARE::fpLOG) ;
goto failed ;
}
}
for (int32_t j = _nAugmentedFunctions - 1 ; j >= 0 ; j--) {
ARE::Function *f = _AugmentedFunctions[j] ;
key.push_back(-f->N()) ;
data.push_back((INT64) f) ;
if (data.size() != key.size()) {
fprintf(ARE::fpLOG, "\n BucketElimination::Bucket::CreateMBPartitioning ERROR : data_size!=key_size(2); i=%d, v=%d, nMBs=%d", (int32_t) _IDX, (int32_t) _V, (int32_t) _MiniBuckets.size()) ;
::fflush(ARE::fpLOG) ;
goto failed ;
}
}
int32_t left[32], right[32] ;
QuickSortLong_i64(key.data(), key.size(), data.data(), left, right) ;
/*
INT64 tS = ARE::GetTimeInMilliseconds() ;
if (_IDX < 2000) {
INT64 dt = tS - tB ;
fprintf(ARE::fpLOG, "\n BucketElimination::Bucket::CreateMBPartitioning; i=%d, v=%d, iBound=%d, nFNs=%d, sorting time=%lld[msec]", (int32_t) _IDX, (int32_t) _V, (int32_t) iBound, (int32_t) data.size(), dt) ;
::fflush(ARE::fpLOG) ; }*/
#ifdef _DEBUG
if (_MiniBuckets.size() > 0) {
int32_t error = 1 ;
}
_MiniBuckets.clear() ;
#endif
//INT64 dtSUM1 = 0, dtSUM2 = 0, dtSUM3 = 0 ; ;
// process functions, one at a time; for each fn, try to add to an existing MB.
for (int32_t j = 0 ; j < key.size() ; j++) {
ARE::Function *f = (ARE::Function*) data[j] ;
bool placed = false ;
for (MiniBucket *mb : _MiniBuckets) {
//INT64 t1 = ARE::GetTimeInMilliseconds() ;
int32_t res = mb->AllowsFunction(*f, iBound, helperArray) ;
//INT64 t2 = ARE::GetTimeInMilliseconds() ;
//dtSUM1 += t2 - t1 ;
if (res < 0)
goto failed ;
if (res > 0) {
placed = true ;
//INT64 t1_ = ARE::GetTimeInMilliseconds() ;
if (0 != mb->AddFunction(*f, helperArray))
goto failed ;
//INT64 t2_ = ARE::GetTimeInMilliseconds() ;
//dtSUM2 += t2_ - t1_ ;
break ;
}
}
if (! placed) {
if (_MiniBuckets.size() > 0 && abandonIfActualPartitioning) {
AbandonIfActualPartitioning = true ;
goto failed ;
}
//INT64 t3 = ARE::GetTimeInMilliseconds() ;
MiniBucket *mb = new MiniBucket ;
if (NULL == mb)
goto failed ;
int32_t existing_size = _MiniBuckets.size() ;
_MiniBuckets.push_back(mb) ;
if (_MiniBuckets.size() != (1+existing_size))
{ delete mb ; goto failed ; }
mb->Initalize(*this, existing_size) ;
for (int32_t idxV = 0 ; idxV < _nVars ; idxV++)
mb->AddVar(_Vars[idxV]) ;
if (0 != mb->AddFunction(*f, helperArray))
goto failed ;
//INT64 t4 = ARE::GetTimeInMilliseconds() ;
//dtSUM3 += t4 - t3 ;
}
}
/*INT64 tMB = ARE::GetTimeInMilliseconds() ;
int32_t div = _IDX%1000 ;
if (_IDX < 2000) {
INT64 dt = tMB - tS ;
fprintf(ARE::fpLOG, "\n BucketElimination::Bucket::CreateMBPartitioning; i=%d, v=%d, nMBs=%d, nFNs=%d, MB partitioning time=%lld(check=%lld, addfn=%lld, new=%lld)", (int32_t) _IDX, (int32_t) _V, (int32_t) _MiniBuckets.size(), (int32_t) data.size(), dt, dtSUM1, dtSUM2, dtSUM3) ;
::fflush(ARE::fpLOG) ;
}*/
// minibuckets for current bucket are now ready, process each and place resulting function
//dtSUM1 = dtSUM2 = dtSUM3 = 0 ; ;
for (MiniBucket *mb : _MiniBuckets) {
ARE::Function & f = mb->OutputFunction() ;
//INT64 t1 = ARE::GetTimeInMilliseconds() ;
if (0 != mb->ComputeOutputFunctionWithScopeWithoutTable()) {
fprintf(ARE::fpLOG, "\n BucketElimination::Bucket::CreateMBPartitioning ERROR : mb->ComputeOutputFunctionWithScopeWithoutTable() failed ...") ;
::fflush(ARE::fpLOG) ;
goto failed ;
}
//INT64 t2 = ARE::GetTimeInMilliseconds() ;
//dtSUM1 += t2 - t1 ;
Bucket *target_bucket = f.Bucket() ; // note target_bucket may be NULL (i.e. when 0==f.N())
for (Bucket *mb_b = ParentBucket() ; mb_b != target_bucket && NULL != mb_b ; mb_b = mb_b->ParentBucket()) {
//t1 = ARE::GetTimeInMilliseconds() ;
//dtSUM1 += t2 - t1 ;
if (0 != mb_b->AddIntermediateFunction(f)) {
fprintf(ARE::fpLOG, "\n BucketElimination::Bucket::CreateMBPartitioning ERROR : mb_b->AddIntermediateFunction() failed ...") ;
::fflush(ARE::fpLOG) ;
goto failed ;
}
//t2 = ARE::GetTimeInMilliseconds() ;
//dtSUM2 += t2 - t1 ;
}
if (NULL != target_bucket) {
//t1 = ARE::GetTimeInMilliseconds() ;
if (0 != target_bucket->AddAugmentedFunction(f)) {
fprintf(ARE::fpLOG, "\n BucketElimination::Bucket::CreateMBPartitioning ERROR : target_bucket->AddAugmentedFunction() failed ...") ;
::fflush(ARE::fpLOG) ;
goto failed ;
}
//t2 = ARE::GetTimeInMilliseconds() ;
//dtSUM3 += t2 - t1 ;
}
}
/*INT64 tE = ARE::GetTimeInMilliseconds() ;
if (_IDX < 2000) {
INT64 dt = tE - tMB ;
fprintf(ARE::fpLOG, "\n BucketElimination::Bucket::CreateMBPartitioning; i=%d, v=%d, MB placing time=%lld[msec] compOFN=%lld +IFN=%lld +AFN=%lld", (int32_t) _IDX, (int32_t) _V, dt, dtSUM1, dtSUM2, dtSUM3) ;
::fflush(ARE::fpLOG) ; }*/
// if requested, do moment-matching
if (CreateTables) {
//INT64 t1 = ARE::GetTimeInMilliseconds() ;
if (0 != ComputeOutputFunctions(doMomentMatching)) {
fprintf(ARE::fpLOG, "\n BucketElimination::Bucket::CreateMBPartitioning ERROR : mb->ComputeOutputFunction() failed ...") ;
::fflush(ARE::fpLOG) ;
goto failed ;
}
/*INT64 t2 = ARE::GetTimeInMilliseconds() ;
INT64 dt = t2 - t1 ;
if (_IDX < 2000) {
INT64 dt = t2 - t1 ;
fprintf(ARE::fpLOG, "\n BucketElimination::Bucket::CreateMBPartitioning; i=%d, v=%d, ComputeOutputFunctions doMomentMatching=%c time=%lld[msec]", (int32_t) _IDX, (int32_t) _V, doMomentMatching ? 'Y' : 'N', dt) ;
::fflush(ARE::fpLOG) ; }*/
}
return 0 ;
failed :
fprintf(ARE::fpLOG, "\n BucketElimination::Bucket::CreateMBPartitioning ERROR : failed label reached (AbandonIfActualPartitioning=%c) ...", AbandonIfActualPartitioning ? 'Y' : 'N') ;
::fflush(ARE::fpLOG) ;
DestroyPartitioning() ;
return 1 ;
}
size_t capacity_get() const
{
return _buffer.capacity();
}
void add( const entry& p )
{
if( points.size() == points.capacity() ) { points.reserve( 2048 ); } // quick and dirty
points.push_back( p );
}
void GetWindows(const cv::Mat& integral_image, std::vector<Shape::Rectangle>& rectangles, const float threshold, const float dist_threshold, std::vector<Shape::Rectangle>& windows, bool append)
{
// Init windows.
if (windows.capacity() < rectangles.size()) windows.reserve(rectangles.size());
if (!append) windows.clear();
// Create disjoint set vector.
DisjointSetVector<Shape::Rectangle> disjoint_set(rectangles);
// Compute edges.
std::vector<Edge > edges;
GetEdges<integral_type, mean_type>(integral_image, disjoint_set, edges);
// Sort edges.
std::sort(edges.begin(), edges.end());
// Merge nodes.
for (std::vector<Edge >::iterator edge = edges.begin(); edge != edges.end(); edge++)
{
edge->Union((Edge::weight_type)threshold);
}
// Get segments.
std::vector<std::vector<std::vector<Shape::Rectangle>::iterator> > sparse_segments(disjoint_set.size());
for (DisjointSetVector<Shape::Rectangle>::iterator node = disjoint_set.begin(); node != disjoint_set.end(); node++)
{
DisjointSetVector<Shape::Rectangle>::pointer root = node->FindRoot();
const size_t id = root - &*disjoint_set.begin();
sparse_segments[id].push_back(node->value());
}
size_t min_area = (integral_image.rows - 1) * (integral_image.cols - 1) / 400;
for (std::vector<std::vector<std::vector<Shape::Rectangle>::iterator> >::iterator sparse_segment = sparse_segments.begin(); sparse_segment != sparse_segments.end(); sparse_segment++)
{
if (!sparse_segment->size() || (sparse_segment->size() == 1 && RectangleArea(*(*sparse_segment)[0]) < min_area)) continue;
Shape::Rectangle window = {integral_image.cols, integral_image.rows, 0, 0};
for (std::vector<std::vector<Shape::Rectangle>::iterator>::iterator rectangle = sparse_segment->begin(); rectangle != sparse_segment->end(); rectangle++)
{
const Shape::Rectangle& r = **rectangle;
window.x1 = std::min(window.x1, r.x1);
window.y1 = std::min(window.y1, r.y1);
window.x2 = std::max(window.x2, r.x2);
window.y2 = std::max(window.y2, r.y2);
}
windows.push_back(window);
}
// Also include nearby windows.
if (dist_threshold <= 0) return;
const int end = windows.size();
for (int i1 = 0; i1 < end; i1++)
{
for (int i2 = i1 + 1; i2 < end; i2++)
{
const Shape::Rectangle& window1 = windows[i1];
const Shape::Rectangle& window2 = windows[i2];
// No need to merge inside windows.
if (IsRectangleInside(window1, window2) || IsRectangleInside(window2, window1) || NormalizedRectangleDist(window2, window1) > 0.5) continue;
Shape::Rectangle window = {std::min(window1.x1, window2.x1), std::min(window1.y1, window2.y1), std::max(window1.x2, window2.x2), std::max(window1.y2, window2.y2)};
windows.push_back(window);
}
}
}
void GetWindows(const cv::Mat& integral_image, std::vector<Shape::Rectangle>& rectangles, std::vector<float>& thresholds, const float dist_threshold, std::vector<Shape::Rectangle>& windows)
{
// Init windows.
if (windows.capacity() < rectangles.size()) windows.reserve(rectangles.size());
windows.clear();
// Create disjoint set vector.
DisjointSetVector<Shape::Rectangle> disjoint_set(rectangles);
// Compute edges.
std::vector<Edge > edges;
GetEdges<integral_type, mean_type>(integral_image, disjoint_set, edges);
// Sort edges.
std::sort(edges.begin(), edges.end());
// Sort threshold.
std::sort(thresholds.begin(), thresholds.end());
// Merge nodes.
std::vector<std::vector<std::vector<Shape::Rectangle>::iterator> > sparse_segments(disjoint_set.size());
std::vector<size_t> sparse_segment_sizes(disjoint_set.size(), 0);
std::vector<Edge > unmerged_edges;
unmerged_edges.reserve(edges.size());
const size_t min_area = (integral_image.rows - 1) * (integral_image.cols - 1) / 400;
std::vector<Shape::Rectangle> small_windows;
if (dist_threshold > 0) small_windows.reserve(rectangles.size());
for (int k = 0; k < thresholds.size(); k++)
{
const float threshold = thresholds[k];
std::vector<Edge >& merging = k & 1 ? unmerged_edges : edges;
std::vector<Edge >& unmerged = k & 1 ? edges : unmerged_edges;
unmerged.clear();
for (std::vector<Edge >::iterator edge = merging.begin(); edge != merging.end(); edge++)
{
if (!edge->Union((Edge::weight_type)threshold))
{
unmerged.push_back(*edge);
}
}
// Get segments.
for (DisjointSetVector<Shape::Rectangle>::iterator node = disjoint_set.begin(); node != disjoint_set.end(); node++)
{
DisjointSetVector<Shape::Rectangle>::pointer root = node->FindRoot();
const size_t id = root - &*disjoint_set.begin();
sparse_segments[id].push_back(node->value());
}
// Get windows.
std::vector<size_t>::iterator sparse_segment_size = sparse_segment_sizes.begin();
for (std::vector<std::vector<std::vector<Shape::Rectangle>::iterator> >::iterator sparse_segment = sparse_segments.begin(); sparse_segment != sparse_segments.end(); sparse_segment++, sparse_segment_size++)
{
if (sparse_segment->size() && sparse_segment->size() != *sparse_segment_size)
{
if (sparse_segment->size() != 1 || RectangleArea(*(*sparse_segment)[0]) > min_area)
{
Shape::Rectangle window = {integral_image.cols, integral_image.rows, 0, 0};
for (std::vector<std::vector<Shape::Rectangle>::iterator>::iterator rectangle = sparse_segment->begin(); rectangle != sparse_segment->end(); rectangle++)
{
const Shape::Rectangle& r = **rectangle;
window.x1 = std::min(window.x1, r.x1);
window.y1 = std::min(window.y1, r.y1);
window.x2 = std::max(window.x2, r.x2);
window.y2 = std::max(window.y2, r.y2);
}
windows.push_back(window);
}
else if (!k && dist_threshold > 0)
{
Shape::Rectangle window = {integral_image.cols, integral_image.rows, 0, 0};
for (std::vector<std::vector<Shape::Rectangle>::iterator>::iterator rectangle = sparse_segment->begin(); rectangle != sparse_segment->end(); rectangle++)
{
const Shape::Rectangle& r = **rectangle;
window.x1 = std::min(window.x1, r.x1);
window.y1 = std::min(window.y1, r.y1);
window.x2 = std::max(window.x2, r.x2);
window.y2 = std::max(window.y2, r.y2);
}
small_windows.push_back(window);
}
}
*sparse_segment_size = sparse_segment->size();
sparse_segment->clear();
}
}
// Also include nearby windows.
if (dist_threshold <= 0) return;
const int end = windows.size();
for (int i1 = 0; i1 < end; i1++)
{
for (int i2 = i1 + 1; i2 < end; i2++)
{
const Shape::Rectangle& window1 = windows[i1];
const Shape::Rectangle& window2 = windows[i2];
// No need to merge inside windows.
if (IsRectangleInside(window1, window2) || IsRectangleInside(window2, window1) || NormalizedRectangleDist(window2, window1) > dist_threshold) continue;
Shape::Rectangle window = {std::min(window1.x1, window2.x1), std::min(window1.y1, window2.y1), std::max(window1.x2, window2.x2), std::max(window1.y2, window2.y2)};
windows.push_back(window);
}
for (std::vector<Shape::Rectangle>::iterator small_window = small_windows.begin(); small_window != small_windows.end(); small_window++)
{
const Shape::Rectangle& window1 = windows[i1];
const Shape::Rectangle& window2 = *small_window;
// No need to merge inside windows.
if (IsRectangleInside(window1, window2) || IsRectangleInside(window2, window1) || NormalizedRectangleDist(window2, window1) > dist_threshold) continue;
Shape::Rectangle window = {std::min(window1.x1, window2.x1), std::min(window1.y1, window2.y1), std::max(window1.x2, window2.x2), std::max(window1.y2, window2.y2)};
windows.push_back(window);
}
}
}
int FPCSRegistrationTools::FindCongruentBases(KDTree* tree,
ScalarType delta,
const CCVector3* base[4],
std::vector<Base>& results)
{
//Compute reference base invariants (r1, r2)
PointCoordinateType r1, r2, d1, d2;
{
const CCVector3* p0 = base[0];
const CCVector3* p1 = base[1];
const CCVector3* p2 = base[2];
const CCVector3* p3 = base[3];
d1 = (*p1-*p0).norm();
d2 = (*p3-*p2).norm();
CCVector3 inter;
if (!LinesIntersections(*p0, *p1, *p2, *p3, inter, r1, r2))
return 0;
}
GenericIndexedCloud* cloud = tree->getAssociatedCloud();
//Find all pairs which are d1-appart and d2-appart
std::vector<IndexPair> pairs1, pairs2;
{
unsigned count = (unsigned)cloud->size();
std::vector<unsigned> pointsIndexes;
try
{
pointsIndexes.reserve(count);
}
catch(...)
{
//not enough memory
return -1;
}
for (unsigned i=0; i<count; i++)
{
const CCVector3 *q0 = cloud->getPoint(i);
IndexPair idxPair;
idxPair.first = i;
//Extract all points from the cloud which are d1-appart (up to delta) from q0
pointsIndexes.clear();
tree->findPointsLyingToDistance(q0->u, static_cast<ScalarType>(d1), delta, pointsIndexes);
{
for(size_t j=0; j<pointsIndexes.size(); j++)
{
//As ||pi-pj|| = ||pj-pi||, we only take care of pairs that verify i<j
if (pointsIndexes[j]>i)
{
idxPair.second = pointsIndexes[j];
pairs1.push_back(idxPair);
}
}
}
//Extract all points from the cloud which are d2-appart (up to delta) from q0
pointsIndexes.clear();
tree->findPointsLyingToDistance(q0->u, static_cast<ScalarType>(d2), delta, pointsIndexes);
{
for(size_t j=0; j<pointsIndexes.size(); j++)
{
if (pointsIndexes[j]>i)
{
idxPair.second = pointsIndexes[j];
pairs2.push_back(idxPair);
}
}
}
}
}
//Select among the pairs the ones that can be congruent to the base "base"
std::vector<IndexPair> match;
{
SimpleCloud tmpCloud1,tmpCloud2;
{
unsigned count = (unsigned)pairs1.size();
if (!tmpCloud1.reserve(count*2)) //not enough memory
return -2;
for(unsigned i=0; i<count; i++)
{
//generate the two intermediate points from r1 in pairs1[i]
const CCVector3 *q0 = cloud->getPoint(pairs1[i].first);
const CCVector3 *q1 = cloud->getPoint(pairs1[i].second);
CCVector3 P1 = *q0 + r1*(*q1-*q0);
tmpCloud1.addPoint(P1);
CCVector3 P2 = *q1 + r1*(*q0-*q1);
tmpCloud1.addPoint(P2);
}
}
{
unsigned count = (unsigned)pairs2.size();
if (!tmpCloud2.reserve(count*2)) //not enough memory
return -3;
for(unsigned i=0; i<count; i++)
{
//generate the two intermediate points from r2 in pairs2[i]
const CCVector3 *q0 = cloud->getPoint(pairs2[i].first);
const CCVector3 *q1 = cloud->getPoint(pairs2[i].second);
CCVector3 P1 = *q0 + r2*(*q1-*q0);
tmpCloud2.addPoint(P1);
CCVector3 P2 = *q1 + r2*(*q0-*q1);
tmpCloud2.addPoint(P2);
}
}
//build kdtree for nearest neighbour fast research
KDTree intermediateTree;
if (!intermediateTree.buildFromCloud(&tmpCloud1))
return -4;
//Find matching (up to delta) intermediate points in tmpCloud1 and tmpCloud2
{
unsigned count = (unsigned)tmpCloud2.size();
match.reserve(count);
if (match.capacity() < count) //not enough memory
return -5;
for(unsigned i=0; i<count; i++)
{
const CCVector3 *q0 = tmpCloud2.getPoint(i);
unsigned a;
if (intermediateTree.findNearestNeighbour(q0->u, a, delta))
{
IndexPair idxPair;
idxPair.first = i;
idxPair.second = a;
match.push_back(idxPair);
}
}
}
}
//Find bases from matching intermediate points indexes
{
results.clear();
size_t count = match.size();
if (count>0)
{
results.reserve(count);
if (results.capacity() < count) //not enough memory
return -6;
for(size_t i=0; i<count; i++)
{
Base quad;
unsigned b = match[i].second / 2;
if ((match[i].second % 2) == 0)
{
quad.a = pairs1[b].first;
quad.b = pairs1[b].second;
}
else
{
quad.a = pairs1[b].second;
quad.b = pairs1[b].first;
}
unsigned a = match[i].first / 2;
if ((match[i].first % 2) == 0)
{
quad.c = pairs2[a].first;
quad.d = pairs2[a].second;
}
else
{
quad.c = pairs2[a].second;
quad.d = pairs2[a].first;
}
results.push_back(quad);
}
}
}
return (int)results.size();
}
void PrintCapNSize(const std::vector<int> &vi)
{
std::cout << "size: " << vi.size()
<< ", capacity: " << vi.capacity()
<< std::endl;
}
bool FPCSRegistrationTools::FilterCandidates(
GenericIndexedCloud *modelCloud,
GenericIndexedCloud *dataCloud,
Base& reference,
std::vector<Base>& candidates,
unsigned nbMaxCandidates,
std::vector<ScaledTransformation>& transforms)
{
std::vector<Base> table;
std::vector<float> scores, sortedscores;
const CCVector3 *p[4], *q;
unsigned i, j;
ScaledTransformation t;
std::vector<ScaledTransformation> tarray;
SimpleCloud referenceBaseCloud, dataBaseCloud;
unsigned candidatesCount = (unsigned)candidates.size();
if (candidatesCount == 0)
return false;
bool filter = (nbMaxCandidates>0 && candidatesCount>nbMaxCandidates);
try
{
table.resize(candidatesCount);
}
catch (.../*const std::bad_alloc&*/) //out of memory
{
return false;
}
for(i=0; i<candidatesCount; i++)
table[i].copy(candidates[i]);
if (!referenceBaseCloud.reserve(4)) //we never know ;)
return false;
for(j=0; j<4; j++)
{
p[j] = modelCloud->getPoint(reference.getIndex(j));
referenceBaseCloud.addPoint(*p[j]);
}
try
{
scores.reserve(candidatesCount);
sortedscores.reserve(candidatesCount);
tarray.reserve(candidatesCount);
transforms.reserve(candidatesCount);
}
catch (.../*const std::bad_alloc&*/) //out of memory
{
return false;
}
//enough memory?
if (scores.capacity() < candidatesCount
|| sortedscores.capacity() < candidatesCount
|| tarray.capacity() < candidatesCount
|| transforms.capacity() < candidatesCount)
{
return false;
}
for(i=0; i<table.size(); i++)
{
dataBaseCloud.clear();
if (!dataBaseCloud.reserve(4)) //we never know ;)
return false;
for(j=0; j<4; j++)
dataBaseCloud.addPoint(*dataCloud->getPoint(table[i].getIndex(j)));
if (!RegistrationTools::RegistrationProcedure(&dataBaseCloud, &referenceBaseCloud, t, false))
return false;
tarray.push_back(t);
if (filter)
{
float score = 0;
GenericIndexedCloud* b = PointProjectionTools::applyTransformation(&dataBaseCloud, t);
if (!b)
return false; //not enough memory
for (j=0; j<4; j++)
{
q = b->getPoint(j);
score += static_cast<float>((*q - *(p[j])).norm());
}
delete b;
scores.push_back(score);
sortedscores.push_back(score);
}
}
if (filter)
{
transforms.clear();
candidates.clear();
try
{
candidates.resize(nbMaxCandidates);
}
catch (.../*const std::bad_alloc&*/) //out of memory
{
return false;
}
candidatesCount=nbMaxCandidates;
//Sort the scores in ascending order and only keep the nbMaxCandidates smallest scores
sort(sortedscores.begin(), sortedscores.end());
float score = sortedscores[nbMaxCandidates-1];
j = 0;
for(i=0; i<scores.size(); i++)
{
if (scores[i]<=score && j<nbMaxCandidates)
{
candidates[i].copy(table[i]);
transforms.push_back(tarray[i]);
j++;
}
}
}
else
{
transforms = tarray;
}
return true;
}
bool ParallelIsAMatch(compat_classad::ClassAd *ad1, std::vector<compat_classad::ClassAd*> &candidates, std::vector<compat_classad::ClassAd*> &matches, int threads, bool halfMatch)
{
int adCount = candidates.size();
static int cpu_count = 0;
int current_cpu_count = threads;
int iterations = 0;
size_t matched = 0;
if(cpu_count != current_cpu_count)
{
cpu_count = current_cpu_count;
if(match_pool)
{
delete[] match_pool;
match_pool = NULL;
}
if(target_pool)
{
delete[] target_pool;
target_pool = NULL;
}
if(matched_ads)
{
delete[] matched_ads;
matched_ads = NULL;
}
}
if(!match_pool)
match_pool = new classad::MatchClassAd[cpu_count];
if(!target_pool)
target_pool = new compat_classad::ClassAd[cpu_count];
if(!matched_ads)
matched_ads = new std::vector<compat_classad::ClassAd*>[cpu_count];
if(!candidates.size())
return false;
for(int index = 0; index < cpu_count; index++)
{
target_pool[index].CopyFrom(*ad1);
match_pool[index].ReplaceLeftAd(&(target_pool[index]));
matched_ads[index].clear();
}
iterations = ((candidates.size() - 1) / cpu_count) + 1;
#ifdef _OPENMP
omp_set_num_threads(cpu_count);
#endif
#pragma omp parallel
{
#ifdef _OPENMP
int omp_id = omp_get_thread_num();
#else
int omp_id = 0;
#endif
for(int index = 0; index < iterations; index++)
{
bool result = false;
int offset = omp_id + index * cpu_count;
if(offset >= adCount)
break;
compat_classad::ClassAd *ad2 = candidates[offset];
/*
if(halfMatch)
{
char const *my_target_type = target_pool[omp_id].GetTargetTypeName();
char const *target_type = ad2->GetMyTypeName();
if( !my_target_type ) {
my_target_type = "";
}
if( !target_type ) {
target_type = "";
}
if( strcasecmp(target_type,my_target_type) &&
strcasecmp(my_target_type,ANY_ADTYPE) )
{
result = false;
continue;
}
}
*/
match_pool[omp_id].ReplaceRightAd(ad2);
if ( !compat_classad::ClassAd::m_strictEvaluation )
{
target_pool[omp_id].alternateScope = ad2;
ad2->alternateScope = &(target_pool[omp_id]);
}
if(halfMatch)
result = match_pool[omp_id].rightMatchesLeft();
else
result = match_pool[omp_id].symmetricMatch();
match_pool[omp_id].RemoveRightAd();
if(result)
{
matched_ads[omp_id].push_back(ad2);
}
}
}
for(int index = 0; index < cpu_count; index++)
{
match_pool[index].RemoveLeftAd();
matched += matched_ads[index].size();
}
if(matches.capacity() < matched)
matches.reserve(matched);
for(int index = 0; index < cpu_count; index++)
{
if(matched_ads[index].size())
matches.insert(matches.end(), matched_ads[index].begin(), matched_ads[index].end());
}
return matches.size() > 0;
}
/*
* ExampleTest.cpp
*
* Created on: Nov 12, 2015
* Author: mobile
*/
#include "catch.hpp"
TEST_CASE( "vectors can be sized and resized", "[vector]" ) {
std::vector<int> v( 5 );
REQUIRE( v.size() == 5 );
REQUIRE( v.capacity() >= 5 );
SECTION( "resizing bigger changes size and capacity" ) {
v.resize( 10 );
REQUIRE( v.size() == 10 );
REQUIRE( v.capacity() >= 10 );
}
SECTION( "resizing smaller changes size but not capacity" ) {
v.resize( 0 );
REQUIRE( v.size() == 0 );
REQUIRE( v.capacity() >= 5 );
}
SECTION( "reserving bigger changes capacity but not size" ) {
v.reserve( 10 );
void printStats(const std::vector<int>& vec) {
std::cout << "size: " << vec.size() << ", ";
std::cout << "cap: " << vec.capacity() << std::endl;
}
int HttpStream::writeData(std::vector<uint8_t> &buf, int buflen) {
if ((int) buf.capacity() < buflen) {
return -1;
}
return writeData(reinterpret_cast<uint8_t *>(&buf[0]), buflen);
}
uint64_t Capacity() { return v.capacity(); }
static inline void shrinkVecToFit(std::vector<Ty_>& vec) {
if (vec.capacity() != vec.size())
std::vector<Ty_>(vec).swap(vec);
}