C++ Path2D::size方法代码示例

	RecognitionResult GeometricRecognizer::recognize(Path2D points)
	{
		//--- Make sure we have some templates to compare this to
		//---  or else recognition will be impossible
        
        if (points.size() < 5){
            return RecognitionResult("Unknown", NULL);
        }
        
        if (templates.empty())
		{
			std::cout << "No templates loaded so no symbols to match." << std::endl;
			return RecognitionResult("Unknown", NULL);
		}

		points = normalizePath(points);
	
		//--- Initialize best distance to the largest possible number
		//--- That way everything will be better than that
		double bestDistance = MAX_DOUBLE;
		//--- We haven't found a good match yet
		int indexOfBestMatch = -1;

		//--- Check the shape passed in against every shape in our database
		for (int i = 0; i < (int)templates.size(); i++)
		{
			//--- Calculate the total distance of each point in the passed in
			//---  shape against the corresponding point in the template
			//--- We'll rotate the shape a few degrees in each direction to
			//---  see if that produces a better match
			double distance = distanceAtBestAngle(points, templates[i]);
			if (distance < bestDistance)
			{
				bestDistance     = distance;
				indexOfBestMatch = i;
			}
		}

		//--- Turn the distance into a percentage by dividing it by 
		//---  half the maximum possible distance (across the diagonal 
		//---  of the square we scaled everything too)
		//--- Distance = hwo different they are
		//--- Subtract that from 1 (100%) to get the similarity
		double score = 1.0 - (bestDistance / halfDiagonal);

		//--- Make sure we actually found a good match
		//--- Sometimes we don't, like when the user doesn't draw enough points
		if (-1 == indexOfBestMatch)
		{
			//cout << "Couldn't find a good match." << endl;
			return RecognitionResult("Unknown", 1);
		}

        cout<<score<<endl;
		RecognitionResult bestMatch(templates[indexOfBestMatch].name, score);
		return bestMatch;
	};

void ShapeDetector::report( const std::string &i_name, const std::vector<CGPoint> &i_path )
{
	Path2D p;
	for ( auto pt : i_path )
	{
		if ( p.size() == 0 )
			p.move_to( pt );
		else
			p.line_to( pt );
	}
	shapeDetected( i_name, p );
}

	Point2D GeometricRecognizer::centroid(Path2D points)
	{
		double x = 0.0, y = 0.0;
		for (Path2DIterator i = points.begin(); i != points.end(); i++)
		{
			Point2D point = *i;
			x += point.x;
			y += point.y;
		}
		x /= points.size();
		y /= points.size();
		return Point2D(x, y);
	}	

std::vector<Vector2f> GeneratePathNormals(const Path2D& path, bool is_closed,
                                          bool outward) {
  assert(path.size() >= 2);
  // Here we are going to use a simple 3-point interpolation method
  // first we need to make the path in ccw direction
  ClipperLib::Path scaled_path = UScalePathDiaToClipper(path);
  if (!ClipperLib::Orientation(scaled_path)) {
    ClipperLib::ReversePath(scaled_path);
  }
  Path2D ccw_path = DScalePathClipperToDia(scaled_path);

  // Special treatment for the first and last point.
  std::vector<Vector2f> output_vecs(path.size());
  if (is_closed) {
    output_vecs[0] =
        GetNormalFromTwoPoints(ccw_path[ccw_path.size() - 1], ccw_path[1]);
    output_vecs.back() =
        GetNormalFromTwoPoints(ccw_path[ccw_path.size() - 2], ccw_path[0]);
  } else {
    output_vecs[0] = GetNormalFromTwoPoints(ccw_path[0], ccw_path[1]);
    output_vecs.back() = GetNormalFromTwoPoints(ccw_path[ccw_path.size() - 2],
                                                ccw_path[ccw_path.size() - 1]);
  }

  // We use the point before and after ith point to interpolate its normal.
  for (size_t i = 1; i < ccw_path.size() - 1; ++i) {
    output_vecs[i] = GetNormalFromTwoPoints(ccw_path[i - 1], ccw_path[i + 1]);
  }

  // Reverse normal direction
  if (!outward) {
    for (size_t i = 0; i < ccw_path.size(); ++i) {
      output_vecs[i] = -output_vecs[i];
    }
  }
  return output_vecs;
}

        vector<double> GeometricRecognizer::vectorize(Path2D points) // for Protractor
        {
                double sum = 0.0;
                vector<double> vectorized;

                // Preprocessing, Move from .x.y notation to 1D vector notation
                // points[i](.x,.y) => vectorized(i, i+1, ...)
                for (unsigned int i = 0; i < points.size(); i++)
                {
                    vectorized.push_back(points[i].x);
                    vectorized.push_back(points[i].y);
                    sum += points[i].x * points[i].x + points[i].y * points[i].y;
                }
                // normalize values : dividing by magnitude
                // magnitude = sqrt ( sum_i(x²) + sum_i(y²) )
                double magnitude = sqrt(sum);
                for (unsigned int i = 0; i < vectorized.size(); i++)
                        vectorized[i] /= magnitude;
                return vectorized;
        }

std::vector<Vector2f> SimplifyPolyline(const Path2D& path, float rel_tol) {
  if (path.size() <= 2) {
    return path;
  }

  std::vector<Vector2f> out;
  if (true) {
    // we compute the boundary square size of the path
    AABB bound = GetAABBWithPadding(path, 0);
    Vector2f span = bound.upper_bound - bound.lower_bound;
    // set a tolerance to remove points that are too close to
    // each other. the relative tolerance is 0.5% of max size
    // so the simplified curve is still pretty smooth
    float tol = std::max(span(0), span(1)) * rel_tol;
    out = PolylineDouglasPeuckerIterative(path, tol);
  } else {
    // only one method implemented
    // the douglas_peucker method may change the topology of input curves
    assert(0);
  }
  return out;
}