Slic3r::Arachne::STHalfEdge Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Arachne/SkeletalTrapezoidationGraph.hpp>

Inheritance diagram for Slic3r::Arachne::STHalfEdge:

Collaboration diagram for Slic3r::Arachne::STHalfEdge:

Public Member Functions
	STHalfEdge (SkeletalTrapezoidationEdge data)
bool	canGoUp (bool strict=false) const
bool	isUpward () const
std::optional< coord_t >	distToGoUp () const
STHalfEdge *	getNextUnconnected ()
bool	operator== (const edge_t &other)

Public Attributes
SkeletalTrapezoidationEdge	data
edge_t *	twin
edge_t *	next
edge_t *	prev
node_t *	from
node_t *	to

Private Types
using	edge_t = STHalfEdge
using	node_t = STHalfEdgeNode

Detailed Description

Member Typedef Documentation

edge_t

using Slic3r::Arachne::STHalfEdge::edge_t = STHalfEdge

private

node_t

using Slic3r::Arachne::STHalfEdge::node_t = STHalfEdgeNode

private

Constructor & Destructor Documentation

STHalfEdge()

Slic3r::Arachne::STHalfEdge::STHalfEdge

(

SkeletalTrapezoidationEdge

data

)

: HalfEdge(data) {}

References Slic3r::Arachne::HalfEdge< SkeletalTrapezoidationJoint, SkeletalTrapezoidationEdge, STHalfEdgeNode, STHalfEdge >::HalfEdge(), and Slic3r::Arachne::HalfEdge< SkeletalTrapezoidationJoint, SkeletalTrapezoidationEdge, STHalfEdgeNode, STHalfEdge >::data.

Referenced by getNextUnconnected().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Function Documentation

canGoUp()

bool Slic3r::Arachne::STHalfEdge::canGoUp

(

bool

strict = false

)

const

Check (recursively) whether there is any upward edge from the distance_to_boundary of the from of the

Parameters

edge
strict	Whether equidistant edges can count as a local maximum

{
    if (to->data.distance_to_boundary > from->data.distance_to_boundary)
    {
        return true;
    }
    if (to->data.distance_to_boundary < from->data.distance_to_boundary || strict)
    {
        return false;
    }
 
    // Edge is between equidistqant verts; recurse!
    for (edge_t* outgoing = next; outgoing != twin; outgoing = outgoing->twin->next)
    {
        if (outgoing->canGoUp())
        {
            return true;
        }
        assert(outgoing->twin); if (!outgoing->twin) return false;
        assert(outgoing->twin->next); if (!outgoing->twin->next) return true; // This point is on the boundary?! Should never occur
    }
    return false;
}

References Slic3r::Arachne::HalfEdge< SkeletalTrapezoidationJoint, SkeletalTrapezoidationEdge, STHalfEdgeNode, STHalfEdge >::from, Slic3r::Arachne::HalfEdge< SkeletalTrapezoidationJoint, SkeletalTrapezoidationEdge, STHalfEdgeNode, STHalfEdge >::next, Slic3r::Arachne::HalfEdge< SkeletalTrapezoidationJoint, SkeletalTrapezoidationEdge, STHalfEdgeNode, STHalfEdge >::to, and Slic3r::Arachne::HalfEdge< SkeletalTrapezoidationJoint, SkeletalTrapezoidationEdge, STHalfEdgeNode, STHalfEdge >::twin.

Referenced by Slic3r::Arachne::STHalfEdgeNode::isLocalMaximum().

Here is the caller graph for this function:

distToGoUp()

std::optional< coord_t > Slic3r::Arachne::STHalfEdge::distToGoUp

(

)

const

Calculate the traversed distance until we meet an upward edge. Useful for calling on edges between equidistant points.

If we can go up then the distance includes the length of the

Parameters

edge

{
    if (to->data.distance_to_boundary > from->data.distance_to_boundary)
    {
        return 0;
    }
    if (to->data.distance_to_boundary < from->data.distance_to_boundary)
    {
        return std::optional<coord_t>();
    }
 
    // Edge is between equidistqant verts; recurse!
    std::optional<coord_t> ret;
    for (edge_t* outgoing = next; outgoing != twin; outgoing = outgoing->twin->next)
    {
        std::optional<coord_t> dist_to_up = outgoing->distToGoUp();
        if (dist_to_up)
        {
            if (ret)
            {
                ret = std::min(*ret, *dist_to_up);
            }
            else
            {
                ret = dist_to_up;
            }
        }
        assert(outgoing->twin); if (!outgoing->twin) return std::optional<coord_t>();
        assert(outgoing->twin->next); if (!outgoing->twin->next) return 0; // This point is on the boundary?! Should never occur
    }
    if (ret)
    {
        ret = *ret + (to->p - from->p).cast<int64_t>().norm();
    }
    return ret;
}

References Slic3r::cast(), Slic3r::Arachne::HalfEdge< SkeletalTrapezoidationJoint, SkeletalTrapezoidationEdge, STHalfEdgeNode, STHalfEdge >::from, Slic3r::Arachne::HalfEdge< SkeletalTrapezoidationJoint, SkeletalTrapezoidationEdge, STHalfEdgeNode, STHalfEdge >::next, Slic3r::Arachne::HalfEdge< SkeletalTrapezoidationJoint, SkeletalTrapezoidationEdge, STHalfEdgeNode, STHalfEdge >::to, and Slic3r::Arachne::HalfEdge< SkeletalTrapezoidationJoint, SkeletalTrapezoidationEdge, STHalfEdgeNode, STHalfEdge >::twin.

Referenced by isUpward().

Here is the call graph for this function:

Here is the caller graph for this function:

getNextUnconnected()

STHalfEdge * Slic3r::Arachne::STHalfEdge::getNextUnconnected

(

)

{
    edge_t* result = static_cast<STHalfEdge*>(this);
    while (result->next)
    {
        result = result->next;
        if (result == this)
        {
            return nullptr;
        }
    }
    return result->twin;
}

References STHalfEdge(), Slic3r::Arachne::HalfEdge< node_data_t, edge_data_t, derived_node_t, derived_edge_t >::next, and Slic3r::Arachne::HalfEdge< node_data_t, edge_data_t, derived_node_t, derived_edge_t >::twin.

Referenced by Slic3r::Arachne::SkeletalTrapezoidation::connectJunctions().

Here is the call graph for this function:

Here is the caller graph for this function:

isUpward()

bool Slic3r::Arachne::STHalfEdge::isUpward

(

)

const

Check whether the edge goes from a lower to a higher distance_to_boundary. Effectively deals with equidistant edges by looking beyond this edge.

{
    if (to->data.distance_to_boundary > from->data.distance_to_boundary)
    {
        return true;
    }
    if (to->data.distance_to_boundary < from->data.distance_to_boundary)
    {
        return false;
    }
 
    // Equidistant edge case:
    std::optional<coord_t> forward_up_dist = this->distToGoUp();
    std::optional<coord_t> backward_up_dist = twin->distToGoUp();
    if (forward_up_dist && backward_up_dist)
    {
        return forward_up_dist < backward_up_dist;
    }
 
    if (forward_up_dist)
    {
        return true;
    }
 
    if (backward_up_dist)
    {
        return false;
    }
    return to->p < from->p; // Arbitrary ordering, which returns the opposite for the twin edge
}

References distToGoUp(), Slic3r::Arachne::HalfEdge< SkeletalTrapezoidationJoint, SkeletalTrapezoidationEdge, STHalfEdgeNode, STHalfEdge >::from, Slic3r::Arachne::HalfEdge< SkeletalTrapezoidationJoint, SkeletalTrapezoidationEdge, STHalfEdgeNode, STHalfEdge >::to, and Slic3r::Arachne::HalfEdge< SkeletalTrapezoidationJoint, SkeletalTrapezoidationEdge, STHalfEdgeNode, STHalfEdge >::twin.

Referenced by Slic3r::Arachne::SkeletalTrapezoidation::generateSegments(), and Slic3r::Arachne::SkeletalTrapezoidation::generateTransitionEnd().

Here is the call graph for this function:

Here is the caller graph for this function:

operator==()

bool Slic3r::Arachne::HalfEdge< SkeletalTrapezoidationJoint, SkeletalTrapezoidationEdge, STHalfEdgeNode, STHalfEdge >::operator== ( const edge_t & other )

inlineinherited

    {
        return this == &other;
    }

Member Data Documentation

data

SkeletalTrapezoidationEdge Slic3r::Arachne::HalfEdge< SkeletalTrapezoidationJoint, SkeletalTrapezoidationEdge, STHalfEdgeNode, STHalfEdge >::data

inherited

Referenced by Slic3r::Arachne::STHalfEdge::STHalfEdge().

from

node_t* Slic3r::Arachne::HalfEdge< SkeletalTrapezoidationJoint, SkeletalTrapezoidationEdge, STHalfEdgeNode, STHalfEdge >::from

inherited

Referenced by Slic3r::Arachne::STHalfEdge::canGoUp(), Slic3r::Arachne::STHalfEdge::distToGoUp(), and Slic3r::Arachne::STHalfEdge::isUpward().

next

edge_t* Slic3r::Arachne::HalfEdge< SkeletalTrapezoidationJoint, SkeletalTrapezoidationEdge, STHalfEdgeNode, STHalfEdge >::next

inherited

Referenced by Slic3r::Arachne::STHalfEdge::canGoUp(), and Slic3r::Arachne::STHalfEdge::distToGoUp().

prev

edge_t* Slic3r::Arachne::HalfEdge< SkeletalTrapezoidationJoint, SkeletalTrapezoidationEdge, STHalfEdgeNode, STHalfEdge >::prev

inherited

to

node_t* Slic3r::Arachne::HalfEdge< SkeletalTrapezoidationJoint, SkeletalTrapezoidationEdge, STHalfEdgeNode, STHalfEdge >::to

inherited

Referenced by Slic3r::Arachne::STHalfEdge::canGoUp(), Slic3r::Arachne::STHalfEdge::distToGoUp(), and Slic3r::Arachne::STHalfEdge::isUpward().

twin

edge_t* Slic3r::Arachne::HalfEdge< SkeletalTrapezoidationJoint, SkeletalTrapezoidationEdge, STHalfEdgeNode, STHalfEdge >::twin

inherited

Referenced by Slic3r::Arachne::STHalfEdge::canGoUp(), Slic3r::Arachne::STHalfEdge::distToGoUp(), and Slic3r::Arachne::STHalfEdge::isUpward().

---

The documentation for this class was generated from the following files:

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Arachne/SkeletalTrapezoidationGraph.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Arachne/SkeletalTrapezoidationGraph.cpp