Candidate.cpp

Go to the documentation of this file.

#include "Candidate.h"
 
Candidate::Candidate() :
    m_subset(0), m_lowerBound(0), m_upperBound(0), m_level(0), m_hasConnectedComponent(false)
{
}
 
Candidate::Candidate(PrimitiveShape* shape, size_t level) :
    m_shape(shape),
    m_subset(0),
    m_lowerBound(0),
    m_upperBound(0),
    m_level(level),
    m_hasConnectedComponent(false)
{
}
 
void
Candidate::Reset()
{
    m_indices->clear();
    m_subset = 0;
    m_lowerBound = 0;
    m_upperBound = 0;
    m_hasConnectedComponent = false;
    m_score = 0;
}
 
void
Candidate::Reindex(const MiscLib::Vector<int>& newIndices,
                   int minInvalidIndex,
                   size_t mergedSubsets,
                   const MiscLib::Vector<size_t>& subsetSizes,
                   const PointCloud& pc,
                   size_t currentSize,
                   float epsilon,
                   float normalThresh,
                   float bitmapEpsilon)
{
    size_t i = 0, j = 0;
    for (; i < m_indices->size(); ++i)
        if (newIndices[(*m_indices)[i]] < minInvalidIndex)
        {
            (*m_indices)[j++] = newIndices[(*m_indices)[i]];
        }
    if (m_subset <= mergedSubsets)
    {
        m_hasConnectedComponent = false;
        m_subset = 0;
        m_indices->clear();
        m_lowerBound = 0;
        m_upperBound = 0; // forget this candidate
        m_score = 0;
        return;
    }
    else
    {
        m_indices->resize(j);
        m_subset -= mergedSubsets;
        if (m_subset >= subsetSizes.size())
        // do connected component if all subsets have been computed
        {
            ConnectedComponent(pc, bitmapEpsilon);
        }
    }
    size_t sampledPoints = 0, endi = std::min(m_subset, subsetSizes.size());
    ;
    for (i = 0; i < endi; ++i)
    {
        sampledPoints += subsetSizes[i];
    }
 
    GetBounds(sampledPoints, currentSize);
}
 
void
Candidate::Reindex(const MiscLib::Vector<size_t>& reindex)
{
    size_t reindexSize = reindex.size();
    for (size_t i = 0; i < m_indices->size(); ++i)
        if (m_indices->at(i) < reindexSize)
        {
            m_indices->at(i) = reindex[m_indices->at(i)];
        }
}
 
float
Candidate::WeightedScore(const PointCloud& pc, float epsilon, float normalThresh) const
{
    float score = 0;
#pragma omp parallel for schedule(static) reduction(+ : score)
    for (intptr_t i = 0; i < (intptr_t)m_indices->size(); ++i)
    {
        score += weigh(m_shape->Distance(pc[(*m_indices)[i]].pos), epsilon);
    }
    return score;
}
 
void
Candidate::ConnectedComponent(const PointCloud& pc, float bitmapEpsilon, float* borderRatio)
{
    size_t oldSize = m_indices->size();
    size_t connectedSize =
        m_shape->ConnectedComponent(pc, bitmapEpsilon, m_indices, true, borderRatio);
    m_indices->resize(connectedSize);
    m_lowerBound = m_upperBound = (float)m_indices->size();
}
 
bool
Candidate::IsEquivalent(const Candidate& c,
                        const PointCloud& pc,
                        float epsilon,
                        float normalThresh) const
{
    if (m_shape->Identifier() != c.m_shape->Identifier())
    {
        return false;
    }
    size_t correct = 0;
    size_t size = std::min(m_indices->size(), (size_t)9);
    for (size_t i = 0; i < size; ++i)
    {
        std::pair<float, float> dn;
        size_t idx = MiscLib::rn_rand() % m_indices->size();
        c.m_shape->DistanceAndNormalDeviation(
            pc[m_indices->at(idx)].pos, pc[m_indices->at(idx)].normal, &dn);
        if (dn.first < epsilon && abs(dn.second) > normalThresh)
        {
            ++correct;
        }
    }
    size_t tested = size;
    size = std::min(c.m_indices->size(), (size_t)9);
    for (size_t i = 0; i < size; ++i)
    {
        std::pair<float, float> dn;
        size_t idx = MiscLib::rn_rand() % c.m_indices->size();
        m_shape->DistanceAndNormalDeviation(
            pc[c.m_indices->at(idx)].pos, pc[c.m_indices->at(idx)].normal, &dn);
        if (dn.first < epsilon && abs(dn.second) > normalThresh)
        {
            ++correct;
        }
    }
    tested += size;
    return correct >= 2 * tested / 3;
}
 
float
Candidate::GetVariance(const PointCloud& pc)
{
    float variance = 0.0f;
    float dev;
 
    if (m_indices->size() > 0)
    {
        // first pass - get expectancy
        float expectancy = 0.0f;
        for (int i = 0; i < m_indices->size(); ++i)
        {
            expectancy +=
                abs(m_shape->NormalDeviation(pc[(*m_indices)[i]].pos, pc[(*m_indices)[i]].normal));
        }
 
        expectancy /= static_cast<float>(m_indices->size());
 
        // second pass - get real variance
        for (int i = 0; i < m_indices->size(); ++i)
        {
            dev =
                abs(m_shape->NormalDeviation(pc[(*m_indices)[i]].pos, pc[(*m_indices)[i]].normal)) -
                expectancy;
            variance += dev * dev;
        }
 
        variance /= static_cast<float>(m_indices->size());
    }
    else
    {
        variance = 1.0f;
    }
 
    return variance;
}
 
float
Candidate::GetPseudoVariance(const PointCloud& pc)
{
    float variance = 0.0f;
    float dev;
 
    for (int i = 0; i < m_indices->size(); ++i)
    {
        dev = abs(m_shape->NormalDeviation(pc[(*m_indices)[i]].pos, pc[(*m_indices)[i]].normal)) -
              1.0f;
        variance += dev * dev;
    }
    variance /= static_cast<float>(m_indices->size());
 
    return variance;
}
 
void
Candidate::GetScore(const PointCloud& pc, float bitmapEpsilon, bool doFiltering)
{
    GetScoreMaxCCSize(pc, bitmapEpsilon, doFiltering);
}
 
void
Candidate::GetScoreMaxCCSize(const PointCloud& pc, float bitmapEpsilon, bool doFiltering)
{
    size_t connectedSize = m_shape->ConnectedComponent(pc, bitmapEpsilon, m_indices, doFiltering);
    m_indices->resize(connectedSize);
 
    m_score = connectedSize;
}
 
void
Candidate::GetScoreMaxCCMinBorder(const PointCloud& pc, float bitmapEpsilon, bool doFiltering)
{
    float borderRatio;
    size_t connectedSize =
        m_shape->ConnectedComponent(pc, bitmapEpsilon, m_indices, doFiltering, &borderRatio);
    m_indices->resize(connectedSize);
 
    m_score = connectedSize * size_t((1.0f - borderRatio) * (1.0f - GetVariance(pc)));
}