LedMeasurement.h

Go to the documentation of this file.

// Copyright 2016 Sensics, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//        http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef INCLUDED_LedMeasurement_h_GUID_FB847F67_347B_4C8E_AC9B_33179ED6B0E6
#define INCLUDED_LedMeasurement_h_GUID_FB847F67_347B_4C8E_AC9B_33179ED6B0E6

// Internal Includes
#include "BasicTypes.h"

// Library/third-party includes
#include <opencv2/core/core.hpp>
#include <opencv2/features2d/features2d.hpp>

// Standard includes
#include <cassert>
#include <vector>

namespace osvr {
namespace vbtracker {
    struct LedMeasurement {
      private:
        static float estimateArea(float diameter) {
            return static_cast<float>((diameter / 2) * (diameter / 2) * CV_PI);
        }

      public:
        LedMeasurement() = default;
        LedMeasurement(cv::Point2f location, float diam, cv::Size imgSize,
                       float beaconArea = -1)
            : loc(location), imageSize(imgSize), brightness(diam),
              diameter(diam),
              area(beaconArea <= 0 ? estimateArea(diameter) : beaconArea) {}

        LedMeasurement(cv::KeyPoint const &kp, cv::Size imgSize,
                       float beaconArea = -1)
            : LedMeasurement(kp.pt, kp.size, imgSize, beaconArea) {
        }

        LedMeasurement(float x, float y, float diam, cv::Size imgSize,
                       float beaconArea = -1)
            : LedMeasurement(cv::Point2f(x, y), diam, imgSize, beaconArea) {
        }

        cv::Point2f loc;

        cv::Size imageSize;

        Brightness brightness;

        float diameter = 0.f;

        float area = 1.f;

        float circularity = 0.f;

        bool knowBoundingBox() const { return knowBoundingBox_; }

        cv::Size2f boundingBoxSize() const {
            assert(knowBoundingBox() && "call to boundingBoxSize() invalid if "
                                        "knowBoundingBox() is false");
            return boundingBox_;
        }

        void setBoundingBox(cv::Size2f size) {
            knowBoundingBox_ = true;
            boundingBox_ = size;
        }

        void setBoundingBox(cv::Rect const &box) {
            knowBoundingBox_ = true;
            boundingBox_ = box.size();
        }

        bool operator==(LedMeasurement const &other) const {
            return loc == other.loc && brightness == other.brightness &&
                   circularity == other.circularity &&
                   knowBoundingBox_ == other.knowBoundingBox_ &&
                   (knowBoundingBox_ ? boundingBox_ == other.boundingBox_
                                     : true) &&
                   // less likely to differ
                   imageSize == other.imageSize &&
                   // technically equivalent or derived from other properties
                   diameter == other.diameter && area == other.area;
        }

      private:
        bool knowBoundingBox_ = false;
        cv::Size2f boundingBox_;
    };

    typedef std::vector<LedMeasurement> LedMeasurementVec;
    typedef LedMeasurementVec::iterator LedMeasurementVecIterator;

} // namespace vbtracker
} // namespace osvr
#endif // INCLUDED_LedMeasurement_h_GUID_FB847F67_347B_4C8E_AC9B_33179ED6B0E6