C++ Path2D类代码示例

	Rectangle GeometricRecognizer::boundingBox(Path2D points)
	{
		double minX =  MAX_DOUBLE;
		double maxX = -MAX_DOUBLE;
		double minY =  MAX_DOUBLE; 
		double maxY = -MAX_DOUBLE;

		for (Path2DIterator i = points.begin(); i != points.end(); i++)
		{
			Point2D point = *i;
			if (point.x < minX)
				minX = point.x;
			if (point.x > maxX)
				maxX = point.x;
			if (point.y < minY)
				minY = point.y;
			if (point.y > maxY)
				maxY = point.y;
		}
		Rectangle bounds(minX, minY, (maxX - minX), (maxY - minY));
		return bounds;
	}

//use 40 point
Path2D CTemplateRecorder::OutputRectange()
{
	Path2D path;
	path.resize(40);
	int curIndex = 0;
	//left edge
	//four points 
	//left bottom 0,0
	//left top 0,100
	//right top 100,100
	//right bottom 100,0
	for(int i=0;i<10;++i)  //left bottom to left top
	{
		path[curIndex].x = 0.0f;
		path[curIndex].y = i*10.0f; 
		curIndex ++;
	}
	for(int i=0;i<10;++i) //left top to right top
	{
		path[curIndex].x = i*10.0f;
		path[curIndex].y = 100.0f; 
		curIndex ++;
	}
	for(int i=0;i<10;++i)  //right top to right bottom
	{
		path[curIndex].x = 100.0f;
		path[curIndex].y = 100.0f - i*10.0f;
		curIndex ++;
	}
	for(int i=0;i<10;++i)
	{
		path[curIndex].x = 100.0f - i*10.0f;
		path[curIndex].y = 0.0f; 
		curIndex ++;
	}
	return path;
}

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;
}

void Shape2D::add_ellipse(const Pointf &center, const Pointf &radius, bool reverse)
{
	float offset_x = 0;
	float offset_y = 0;

	int max_radius = max(radius.x, radius.y);

	int rotationcount = max(5, (max_radius - 3));
	float halfpi = 1.5707963267948966192313216916398f;
	float turn = halfpi / rotationcount;

	offset_x = center.x;
	offset_y = -center.y;

	Path2D path;

	rotationcount *= 4;

	std::vector<Pointf> points;
	points.resize(rotationcount);

	for(int i = 0; i < rotationcount ; i++)
	{
		float pos1 = radius.x * cos(i * turn);
		float pos2 = radius.y * sin(i * turn);

		points[i].x = (center.x + pos1);
		points[i].y = (center.y + pos2);
	}

	path.add_line_to(points);

	if (reverse)
		path.reverse();

	add_path(path);
}

Path2D Path2D::circle( CGFloat r, const CGPoint &i_center )
{
	Path2D p;
	r = std::abs( r );
	CGFloat c = r * 0.551915024494;
	p.move_to( i_center + CGPoint{ r, 0 } );
	p.curve_to( i_center + CGPoint{ r, c }, i_center + CGPoint{ c, r }, i_center + CGPoint{ 0, r } );
	p.curve_to( i_center + CGPoint{ -c, r }, i_center + CGPoint{ -r, c }, i_center + CGPoint{ -r, 0 } );
	p.curve_to( i_center + CGPoint{ -r, -c }, i_center + CGPoint{ -c, -r }, i_center + CGPoint{ 0, -r } );
	p.curve_to( i_center + CGPoint{ c, -r }, i_center + CGPoint{ r, -c }, i_center + CGPoint{ r, 0 } );
	p.close();
	return p;
}

void Shape2D_Impl::add_rotated_curve(Path2D &path, const Pointf &center, const Angle &angle, Pointf point_1,  Pointf point_2,  Pointf point_3)
{
	if (angle.to_radians() != 0.0f)
	{
		point_1.rotate(center, angle);
		point_2.rotate(center, angle);
		point_3.rotate(center, angle);
	}
	BezierCurve curve;
	curve.add_control_point(point_1);
	curve.add_control_point(point_2);
	curve.add_control_point(point_3);
	path.add_curve(curve);

}

        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;
}

Shape2D FontEngine_Freetype::load_glyph_outline(int c, int &out_advance_x)
{
	out_advance_x = 0;

	FT_UInt glyph_index;

	glyph_index = FT_Get_Char_Index( face, FT_ULong(c) );

	FT_Error error = FT_Load_Glyph( face, glyph_index, FT_LOAD_DEFAULT );
	if ( error )
	{
		throw Exception("freetype: error loading glyph");
	}

	FT_Glyph glyph;

	error = FT_Get_Glyph( face->glyph, &glyph );

	if ( error )
	{
		throw Exception("freetype: error getting glyph");
	}

	FT_OutlineGlyph ft_outline_glyph_rec = (FT_OutlineGlyph)glyph;
	FT_Outline ft_outline = ft_outline_glyph_rec->outline;

	Shape2D outline;

//	cl_write_console_line(string_format("Num contours: %1", ft_outline.n_contours));

	for( int cont = 0; cont < ft_outline.n_contours; cont++ )
	{
//		cl_write_console_line(string_format("Num points in contour %1: %2", cont, ft_outline.contours[0]+1));

		Path2D contour;

		// debug: dump contents of points array to terminal
//		for( int i = 0; i <= ft_outline.contours[cont]; ++i )
//		{
//			FT_Vector pos = ft_outline.points[i];
//			cl_write_console_line(string_format("dump points[%1]: (%2,%3) \t type: %4", i, pos.x, pos.y, ft_outline.tags[i]));
//		}

		std::vector<TaggedPoint> points = get_contour_points(cont, &ft_outline);
		points.push_back(points.front()); // just to simplify, it's removed later.

		for( unsigned int i = 0; i < points.size()-1; i++ )
		{
			TaggedPoint &tp = points[i];

			if( tp.tag == FT_Curve_Tag_On )
			{
				contour.add_line_to(tp.pos);
			}
			else if( tp.tag == FT_Curve_Tag_Conic )
			{
				// TODO: i - 1 is safe here because we made sure the contour will start with a Tag_On.
				BezierCurve curve;
				curve.add_control_point( points[i-1].pos);
				curve.add_control_point( tp.pos );
				curve.add_control_point( points[i+1].pos );
				contour.add_curve(curve);
			}
			else if( tp.tag == FT_Curve_Tag_Cubic && points[i-1].tag == FT_Curve_Tag_Cubic )
			{
				BezierCurve curve;
				curve.add_control_point( points[i-2].pos);
				curve.add_control_point( points[i-1].pos);
				curve.add_control_point( tp.pos );
				curve.add_control_point( points[i+1].pos );
				contour.add_curve(curve);
			}
		}

		outline.add_path(contour);
	}

	FT_Done_Glyph(glyph);

	out_advance_x = get_advance_x( c );

	return outline;
}

	Path2D GeometricRecognizer::resample(Path2D points)
	{
        double interval = pathLength(points) / (numPointsInGesture - 1); // interval length
        double D = 0.0;
        Path2D newPoints;
        if (!points.empty()){
            //--- Store first point since we'll never resample it out of existence
            newPoints.push_back(points.front());
            for(int i = 1; i < (int)points.size(); i++)
            {
                Point2D currentPoint  = points[i];
                Point2D previousPoint = points[i-1];
                double d = getDistance(previousPoint, currentPoint);
                if ((D + d) >= interval)
                {
                    double qx = previousPoint.x + ((interval - D) / d) * (currentPoint.x - previousPoint.x);
                    double qy = previousPoint.y + ((interval - D) / d) * (currentPoint.y - previousPoint.y);
                    Point2D point(qx, qy);
                    newPoints.push_back(point);
                    points.insert(points.begin() + i, point);
                    D = 0.0;
                }
                else D += d;
            }
            
            // somtimes we fall a rounding-error short of adding the last point, so add it if so
            if (newPoints.size() == (numPointsInGesture - 1))
            {
                newPoints.push_back(points.back());
            }
        }
		return newPoints;
	}