This file is indexed.

/usr/include/visp/vpPolygon.h is in libvisp-dev 2.9.0-3+b2.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
/****************************************************************************
 *
 * $Id: vpPolygon.h 4574 2014-01-09 08:48:51Z fspindle $
 *
 * This file is part of the ViSP software.
 * Copyright (C) 2005 - 2014 by INRIA. All rights reserved.
 * 
 * This software is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * ("GPL") version 2 as published by the Free Software Foundation.
 * See the file LICENSE.txt at the root directory of this source
 * distribution for additional information about the GNU GPL.
 *
 * For using ViSP with software that can not be combined with the GNU
 * GPL, please contact INRIA about acquiring a ViSP Professional 
 * Edition License.
 *
 * See http://www.irisa.fr/lagadic/visp/visp.html for more information.
 * 
 * This software was developed at:
 * INRIA Rennes - Bretagne Atlantique
 * Campus Universitaire de Beaulieu
 * 35042 Rennes Cedex
 * France
 * http://www.irisa.fr/lagadic
 *
 * If you have questions regarding the use of this file, please contact
 * INRIA at visp@inria.fr
 * 
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 *
 * Description:
 * Defines a generic 2D polygon.
 *
 * Author:
 * Amaury Dame
 * Nicolas Melchior
 * Romain Tallonneau
 *
 *****************************************************************************/

#ifndef vpPolygon_h
#define vpPolygon_h

/*!
  \class vpPolygon
  \brief Defines a generic 2D polygon.
  
  A polygon is internally represented by N 2D points.
  
  By default three coordinates in the \f$ (i,j) \f$ frame (see vpImagePoint
  class documentation for more details about the frame) are used \f$ (0,0) \f$,
 \f$ (1,0) \f$ and \f$ (0,1) \f$.

  The code bellow shows how to manipulate a polygon.
\code
#include <iostream>

#include <visp/vpPolygon.h>

int main()
{
  std::vector<vpImagePoint> corners;

  // Initialize the corners vector with 4 points 
  corners.push_back( vpImagePoint( 50, 100) );
  corners.push_back( vpImagePoint( 50, 300) );
  corners.push_back( vpImagePoint(200, 300) );
  corners.push_back( vpImagePoint(200, 100) );

  // Initialize a polygon with the corners
  vpPolygon polygon(corners);

  // Get the polygon bounding box
  vpRect bbox = polygon.getBoundingBox();
  std::cout << "Bounding box: " << bbox.getTopLeft() << " to " << bbox.getBottomRight() << std::endl;

  // Get the polygon surface and center
  std::cout << "Area: " << polygon.getArea() << std::endl;
  std::cout << "Center: " << polygon.getCenter() << std::endl;

  // Check if a point is inside the polygon
  vpImagePoint ip(550, 200);
  std::cout << "The point " << ip << " is " << (polygon.isInside(ip) ? "inside":"outside") << " the polygon" << std::endl; 

  return 0;
}
\endcode
*/

#include <visp/vpImagePoint.h>
#include <visp/vpRect.h>
#include <visp/vpColor.h>
#include <visp/vpImage.h>
#include <visp/vpPoint.h>
#include <visp/vpCameraParameters.h>

#include <vector>

class VISP_EXPORT vpPolygon
{
  protected:
    //! Collection of image points containing the corners.
    std::vector<vpImagePoint> _corners;
    //! Center of the polygon. It is automatically computed when the corners are set.
    vpImagePoint _center;
    //! Area of the polygon.
    double _area;
    //! Flag to indicate whether the polygon is a good polygon (ie. it has more than two corners, ...)
    bool _goodPoly;
    //! Boumding box containing the polygon.
    vpRect _bbox;
    
  public:
    vpPolygon();
    vpPolygon(const std::vector<vpImagePoint>& corners);
    vpPolygon(const vpPolygon &poly);
    virtual ~vpPolygon();
    
    vpPolygon &operator=(const vpPolygon& poly);
    
    void buildFrom(const std::vector<vpImagePoint>& corners);
    void buildFrom(const std::vector<vpPoint>& corners, const vpCameraParameters& cam);
    void initClick(const vpImage<unsigned char>& I);
    
    bool isInside(const vpImagePoint &iP);

    void display(const vpImage<unsigned char>& I, const vpColor& color, unsigned int thickness=1);
    
    /*!
      Get the corners of the polygon.
      
      \return A reference to the corners.
    */
    const std::vector<vpImagePoint>& getCorners() const {
      return _corners;
    }
      
      
    /*!
      Return the area of the polygon.
      The area is computed when the polygon is built from the corners.
      
      \return The area of the polygon.
    */
    inline double getArea() const{
      return this->_area;
    }

    /*!
      Return the center of the polygon.
      The center is computed when the polygon is built from the corners.

      \return The area of the polygon.
    */
    inline vpImagePoint getCenter() const{
      return this->_center;
    }

    /*!
      Return the bounding box. The bounding box is the smallest rectangle
      containing all the polygon.

      \return The bounding box of the polygon.
    */
    inline vpRect getBoundingBox() const {
      return _bbox;
    }

  protected:
    void init(const std::vector<vpImagePoint>& corners);
    void updateArea();
    void updateCenter();
    void updateBoundingBox();
    
  private:
    bool testIntersectionSegments(const vpImagePoint& ip1, const vpImagePoint& ip2, const vpImagePoint& ip3, const vpImagePoint& ip4);
    
};

#endif