LowStretchSphereParametrization.cpp

Go to the documentation of this file.

#include "LowStretchSphereParametrization.h"
 
#include "Bitmap.h"
 
LowStretchSphereParametrization::LowStretchSphereParametrization(const Sphere& sphere) :
    m_sphere(&sphere)
{
    m_frame.Canonical();
}
 
void
LowStretchSphereParametrization::Shape(const Sphere& sphere)
{
    m_sphere = &sphere;
    m_frame.Canonical();
}
 
void
LowStretchSphereParametrization::WrapComponents(
    const GfxTL::AABox<GfxTL::Vector2Df>& bbox,
    float epsilon,
    size_t uextent,
    size_t vextent,
    MiscLib::Vector<int>* componentImg,
    MiscLib::Vector<std::pair<int, size_t>>* labels) const
{
    // wraps are necessary only in v direction
    // relabel the components
    MiscLib::Vector<std::pair<int, size_t>> tempLabels(*labels);
    // wrap along v
    float vstartPrev, vendPrev, vstart = 0, vend = 0, vstartNext = 0, vendNext = 0;
    size_t vsPrev, vePrev, vs = 0, ve = 0, vsNext = 0, veNext = 0;
    float uangle = (bbox.Min()[0] + .5f * epsilon) / m_sphere->Radius();
    float radius = std::sin(uangle) * m_sphere->Radius();
    vstartNext = float(-M_PI) * radius;
    vendNext = float(M_PI) * radius;
    vsNext =
        std::min(vextent - 1,
                 (size_t)std::max((intptr_t)0, (intptr_t)((vstartNext - bbox.Min()[1]) / epsilon)));
    veNext = (size_t)std::max(
        (intptr_t)0,
        std::min((intptr_t)vextent - 1, (intptr_t)((vendNext - bbox.Min()[1]) / epsilon)));
    for (size_t u = 0; u < uextent; ++u)
    {
        vstartPrev = vstart;
        vstart = vstartNext;
        vendPrev = vend;
        vend = vendNext;
        vsPrev = vs;
        vs = vsNext;
        vePrev = ve;
        ve = veNext;
        // determine starting position in the next column
        if (u < uextent - 1)
        {
            float uangleNext = ((u + 1.5f) * epsilon + bbox.Min()[0]) / m_sphere->Radius();
            float radiusNext = std::sin(uangle) * m_sphere->Radius();
            vstartNext = float(-M_PI) * radius;
            vendNext = float(M_PI) * radius;
            vsNext = std::min(
                vextent - 1,
                (size_t)std::max((intptr_t)0, (intptr_t)((vstartNext - bbox.Min()[1]) / epsilon)));
            veNext = (size_t)std::max(
                (intptr_t)0,
                std::min((intptr_t)vextent - 1, (intptr_t)((vendNext - bbox.Min()[1]) / epsilon)));
        }
        if (vstart <= bbox.Min()[1] - epsilon || vend >= bbox.Max()[1] + epsilon ||
            !(*componentImg)[vs * uextent + u])
        {
            continue;
        }
        // check the three neighbors on the other side
        if ((*componentImg)[ve * uextent + u])
            AssociateLabel(
                (*componentImg)[vs * uextent + u], (*componentImg)[ve * uextent + u], &tempLabels);
        if (u > 0 && vstartPrev > bbox.Min()[1] - epsilon && vendPrev < bbox.Min()[1] + epsilon &&
            (*componentImg)[vePrev * uextent + u - 1])
            AssociateLabel((*componentImg)[vs * uextent + u],
                           (*componentImg)[vePrev * uextent + u - 1],
                           &tempLabels);
        if (u < uextent - 1 && vstartNext > bbox.Min()[1] - epsilon &&
            vendNext < bbox.Min()[1] + epsilon && (*componentImg)[veNext * uextent + u + 1])
            AssociateLabel((*componentImg)[vs * uextent + u],
                           (*componentImg)[veNext * uextent + u + 1],
                           &tempLabels);
    }
 
    // condense labels
    for (size_t i = tempLabels.size() - 1; i > 0; --i)
    {
        tempLabels[i].first = ReduceLabel(i, tempLabels);
    }
    MiscLib::Vector<int> condensed(tempLabels.size());
    labels->clear();
    labels->reserve(condensed.size());
    int count = 0;
    for (size_t i = 0; i < tempLabels.size(); ++i)
        if (i == tempLabels[i].first)
        {
            labels->push_back(std::make_pair(count, tempLabels[i].second));
            condensed[i] = count;
            ++count;
        }
        else
            (*labels)[condensed[tempLabels[i].first]].second += tempLabels[i].second;
    // set new component ids
    for (size_t i = 0; i < componentImg->size(); ++i)
        (*componentImg)[i] = condensed[tempLabels[(*componentImg)[i]].first];
}
 
size_t
LowStretchSphereParametrization::SerializedSize()
{
    return sizeof(GfxTL::Frame<3, float>::PointType) + sizeof(float);
}
 
void
LowStretchSphereParametrization::Serialize(std::ostream* o, bool binary) const
{
    // defer rotation from frame
    GfxTL::Frame<3, float> nframe;
    nframe.FromNormal(m_frame[2]);
    GfxTL::VectorXD<2, float> t;
    nframe.ToTangent(m_frame[0], &t);
    for (unsigned int i = 0; i < 2; ++i)
    {
        t[i] = GfxTL::Math<float>::Clamp(t[i], -1, 1);
    }
    float angle = std::atan2(t[1], t[0]);
    // write normal and dummy rotation
    if (binary)
    {
        o->write((char*)&m_frame[2], sizeof(GfxTL::Frame<3, float>::PointType));
        o->write((char*)&angle, sizeof(angle));
    }
    else
    {
        for (unsigned int i = 0; i < 3; ++i)
        {
            (*o) << m_frame[2][i] << " ";
        }
        (*o) << angle << " ";
    }
}
 
void
LowStretchSphereParametrization::Deserialize(std::istream* i, bool binary)
{
    float rot;
    GfxTL::Frame<3, float>::PointType normal;
    if (binary)
    {
        i->read((char*)&normal, sizeof(normal));
        i->read((char*)&rot, sizeof(rot));
    }
    else
    {
        for (unsigned int j = 0; j < 3; ++j)
        {
            (*i) >> normal[j];
        }
        (*i) >> rot;
    }
    m_frame.FromNormal(normal);
    m_frame.RotateOnNormal(rot);
}