C++ Interval::empty方法代碼示例

//! Return the range of numbers that might be used with this format to
//! represent a number within `x`.
Interval FloatFormat::convert (const Interval& x) const
{
	Interval ret;
	Interval tmp = x;

	if (x.hasNaN())
	{
		// If NaN might be supported, NaN is a legal return value
		if (m_hasNaN != NO)
			ret |= TCU_NAN;

		// If NaN might not be supported, any (non-NaN) value is legal,
		// _subject_ to clamping. Hence we modify tmp, not ret.
		if (m_hasNaN != YES)
			tmp = Interval::unbounded();
	}

	// Round both bounds _inwards_ to closest representable values.
	if (!tmp.empty())
		ret |= clampValue(round(tmp.lo(), true)) | clampValue(round(tmp.hi(), false));

	// If this format's precision is not exact, the (possibly out-of-bounds)
	// original value is also a possible result.
	if (!m_exactPrecision)
		ret |= x;

	return ret;
}

/**
Calculates the intersection of this interval with another.

@param rhs	The other interval
@return		The intersection of the two intervals
*/
Interval Interval::intersect(const Interval& rhs) const
{
	if(empty() || rhs.empty()) return Interval();

	double largerLow = std::max(m_low, rhs.m_low);
	double smallerHigh = std::min(m_high, rhs.m_high);
	return Interval(largerLow, smallerHigh);
}

//! Round output of an operation.
//! \param roundUnderOverflow Can +/-inf rounded to min/max representable;
//!							  should be false if any of operands was inf, true otherwise.
Interval FloatFormat::roundOut (const Interval& x, bool roundUnderOverflow) const
{
	Interval ret = x.nan();

	if (!x.empty())
		ret |= Interval(roundOut(x.lo(), false, roundUnderOverflow),
						roundOut(x.hi(), true, roundUnderOverflow));

	return ret;
}

std::string FloatFormat::intervalToHex (const Interval& interval) const
{
	if (interval.empty())
		return interval.hasNaN() ? "{ NaN }" : "{}";

	else if (interval.lo() == interval.hi())
		return (std::string(interval.hasNaN() ? "{ NaN, " : "{ ") +
				floatToHex(interval.lo()) + " }");
	else if (interval == Interval::unbounded(true))
		return "<any>";

	return (std::string(interval.hasNaN() ? "{ NaN } | " : "") +
			"[" + floatToHex(interval.lo()) + ", " + floatToHex(interval.hi()) + "]");
}

void ManhattanGroundTruth::ProcessWalls(const proto::FloorPlan& fp,
                                        const PosedCamera& pc) {
    // Initialize
    nocclusions = 0;
    nwalls = 0;

    // First strip out the NaN vertices
    vector<Vec2> verts;
    for (int i = 0; i < fp.vertices_size(); i++) {
        Vec2 v = asToon(fp.vertices(i));
        if (!isnan(v[0]) && !isnan(v[1])) {
            verts.push_back(v);
        }
    }

    // Compute rectifier in retina coords
    Mat3 ret_vrect = GetVerticalRectifierInRetina(pc);
    Mat3 ret_vrect_inv = LU<3>(ret_vrect).get_inverse();
    Bounds2D<> ret_vrect_bounds = Bounds2D<>::ComputeBoundingBox
                                  (pc.retina_bounds().GetPolygon().Transform(ret_vrect));
    Interval xbounds(ret_vrect_bounds.left(), ret_vrect_bounds.right());

    // Note that the floorplan vertices do _not_ wrap around
    Vec3 focal_line = makeVector(0, -1, 1e-6);

    vector<Vec3> lines;
    vector<Interval> intervals;
    for (int i = 0; i < verts.size()-1; i++) {
        Vec3 a_cam = ret_vrect * (pc.pose() * concat(verts[i], 0.0));
        Vec3 b_cam = ret_vrect * (pc.pose() * concat(verts[i+1], 0.0));
        Vec3 a_flat = makeVector(a_cam[0], a_cam[2], 1.0);  // y no longer matters, and now homog
        Vec3 b_flat = makeVector(b_cam[0], b_cam[2], 1.0);  // y no longer matters, and now homog
        bool nonempty = ClipAgainstLine(a_flat, b_flat, focal_line, -1);
        if (nonempty) {
            // project() must come after clipping
            Vec2 a0 = project(a_flat);
            Vec2 b0 = project(b_flat);
            intervals.push_back(Interval(a0[0]/a0[1], b0[0]/b0[1]));
            lines.push_back(a_flat ^ b_flat);
        }
    }

    // Compare polygons
    MatI interval_comp(verts.size()-1, verts.size()-1);
    for (int i = 0; i < intervals.size(); i++) {
        for (int j = 0; j < intervals.size(); j++) {
            if (i==j) continue;
            Interval isct = Intersect(intervals[i], intervals[j]);
            if (isct.empty()) {
                interval_comp[i][j] = i>j ? 1 : -1;
            } else {
                double m = (isct.hi + isct.lo) / 2.;
                double zi = -lines[i][2] / (lines[i][0]*m + lines[i][1]);
                double zj = -lines[j][2] / (lines[j][0]*m + lines[j][1]);
                interval_comp[i][j] = zi > zj ? 1 : -1;
            }
        }
    }

    // Generate tokens
    vector<Token> tokens;
    for (int i = 0; i < intervals.size(); i++) {
        tokens.push_back(Token(intervals[i].lo, i, true));
        tokens.push_back(Token(intervals[i].hi, i, false));
    }
    // Add tokens for left and right image bounds
    tokens.push_back(Token(xbounds.lo, -1, true));
    tokens.push_back(Token(xbounds.hi, -1, false));
    sort_all(tokens);

    // Walk from left to right
    vector<Vec2> xs;
    int prev = -1;
    bool inbounds = false;
    bool done = false;
    VecI active(intervals.size(), 0);
    TableComp comp(interval_comp);
    priority_queue<int,vector<int>,TableComp> heap(comp);
    for (int i = 0; !done; i++) {
        // Process next token
        bool bound_token = tokens[i].index == -1;
        if (bound_token && tokens[i].activate) {
            inbounds = true;
        } else if (bound_token && !tokens[i].activate) {
            done = true;
        } else if (tokens[i].activate) {
            active[tokens[i].index] = true;
            heap.push(tokens[i].index);
        } else {
            active[tokens[i].index] = false;
            while (!heap.empty() && !active[heap.top()]) {  // okay for heap to be temporarily empty
                heap.pop();
            }
        }

        double xcur = tokens[i].x;
        if ((tokens[i+1].x-xcur) > 1e-8) {
            int cur = heap.empty() ? -1 : heap.top();

            // Count walls
//.........這裏部分代碼省略.........

void NavMeshGenerator::determine_links()
{
	for(EdgePlaneTable::const_iterator it=m_edgePlaneTable.begin(), iend=m_edgePlaneTable.end(); it!=iend; ++it)
	{
		// Generate (n,u,v) coordinate system for plane, where v = (0,0,1).
		const Plane& plane = it->first;
		OrthonormalCoordSystem2D coordSystem(plane);

		// Check pairs of different-facing edges to see whether we need to create any links.
		const EdgeReferences& sameFacingEdgeRefs = it->second.sameFacing;
		const EdgeReferences& oppFacingEdgeRefs = it->second.oppFacing;
		int sameFacingEdgeRefCount = static_cast<int>(sameFacingEdgeRefs.size());
		int oppFacingEdgeRefCount = static_cast<int>(oppFacingEdgeRefs.size());

		for(int j=0; j<sameFacingEdgeRefCount; ++j)
		{
			const EdgeReference& edgeJ = sameFacingEdgeRefs[j];
			NavPolygon& navPolyJ = *m_walkablePolygons[edgeJ.navPolyIndex];
			const CollisionPolygon& colPolyJ = *m_polygons[navPolyJ.collision_poly_index()];
			int mapIndexJ = colPolyJ.auxiliary_data().map_index();

			// Calculate the 2D coordinates of edgeJ in the plane.
			const Vector3d& p1J = colPolyJ.vertex(edgeJ.startVertex);
			const Vector3d& p2J = colPolyJ.vertex((edgeJ.startVertex+1) % colPolyJ.vertex_count());
			Vector2d q1J = coordSystem.from_canonical(p1J), q2J = coordSystem.from_canonical(p2J);
			Interval xIntervalJ(std::min(q1J.x,q2J.x), std::max(q1J.x,q2J.x));

			for(int k=0; k<oppFacingEdgeRefCount; ++k)
			{
				const EdgeReference& edgeK = oppFacingEdgeRefs[k];
				NavPolygon& navPolyK = *m_walkablePolygons[edgeK.navPolyIndex];
				const CollisionPolygon& colPolyK = *m_polygons[navPolyK.collision_poly_index()];
				int mapIndexK = colPolyK.auxiliary_data().map_index();

				// We only want to create links between polygons in the same map.
				if(mapIndexJ != mapIndexK) continue;

				// Calculate the 2D coordinates of edgeK in the plane.
				const Vector3d& p1K = colPolyK.vertex(edgeK.startVertex);
				const Vector3d& p2K = colPolyK.vertex((edgeK.startVertex+1) % colPolyK.vertex_count());
				Vector2d q1K = coordSystem.from_canonical(p1K), q2K = coordSystem.from_canonical(p2K);

				// Calculate the x overlap between the 2D edges. If there's no overlap,
				// then we don't need to carry on looking for a link.
				Interval xIntervalK(std::min(q1K.x,q2K.x), std::max(q1K.x,q2K.x));
				Interval xOverlap = xIntervalJ.intersect(xIntervalK);
				if(xOverlap.empty()) continue;

				// Calculate the segments for the various types of link.
				LinkSegments linkSegments = calculate_link_segments(q1J, q2J, q1K, q2K, xOverlap);

				// Add the appropriate links.
				if(linkSegments.stepDownSourceToDestSegment)
				{
					assert(linkSegments.stepUpDestToSourceSegment != NULL);

					// Add a step down link from j -> k, and a step up one from k -> j.
					Vector3d j1 = coordSystem.to_canonical(linkSegments.stepDownSourceToDestSegment->e1);
					Vector3d j2 = coordSystem.to_canonical(linkSegments.stepDownSourceToDestSegment->e2);
					Vector3d k1 = coordSystem.to_canonical(linkSegments.stepUpDestToSourceSegment->e1);
					Vector3d k2 = coordSystem.to_canonical(linkSegments.stepUpDestToSourceSegment->e2);
					add_nav_link(NavLink_Ptr(new StepDownLink(edgeJ.navPolyIndex, edgeK.navPolyIndex, j1, j2, k1, k2)));
					add_nav_link(NavLink_Ptr(new StepUpLink(edgeK.navPolyIndex, edgeJ.navPolyIndex, k1, k2, j1, j2)));
				}
				if(linkSegments.stepUpSourceToDestSegment)
				{
					assert(linkSegments.stepDownDestToSourceSegment != NULL);

					// Add a step up link from j -> k, and a step down one from k -> j.
					Vector3d j1 = coordSystem.to_canonical(linkSegments.stepUpSourceToDestSegment->e1);
					Vector3d j2 = coordSystem.to_canonical(linkSegments.stepUpSourceToDestSegment->e2);
					Vector3d k1 = coordSystem.to_canonical(linkSegments.stepDownDestToSourceSegment->e1);
					Vector3d k2 = coordSystem.to_canonical(linkSegments.stepDownDestToSourceSegment->e2);
					add_nav_link(NavLink_Ptr(new StepUpLink(edgeJ.navPolyIndex, edgeK.navPolyIndex, j1, j2, k1, k2)));
					add_nav_link(NavLink_Ptr(new StepDownLink(edgeK.navPolyIndex, edgeJ.navPolyIndex, k1, k2, j1, j2)));
				}
				if(linkSegments.walkSegment)
				{
					// Add a walk link from j -> k, and one from k -> j.
					Vector3d e1 = coordSystem.to_canonical(linkSegments.walkSegment->e1);
					Vector3d e2 = coordSystem.to_canonical(linkSegments.walkSegment->e2);
					add_nav_link(NavLink_Ptr(new WalkLink(edgeJ.navPolyIndex, edgeK.navPolyIndex, e1, e2)));
					add_nav_link(NavLink_Ptr(new WalkLink(edgeK.navPolyIndex, edgeJ.navPolyIndex, e1, e2)));
				}
			}
		}
	}
}