Esempio n. 1
0
Geometry* BezierSpline::scatter() const
{
	CoordinateArraySequence cds;
	Coordinate cd,p0,p1,p2,p3;
	double t;

	for(int i=0; i<m_firstControlPoints.size(); i++)
	{
		p0 = m_knots[i];
		p1 = m_firstControlPoints[i];
		p2 = m_secondControlPoints[i];
		p3 = m_knots[i+1];

		for(int j=0; j<=10; j++)
		{
			t = j*0.1;
			cd.x = (1-t)*(1-t)*(1-t)*p0.x + 3*(1-t)*(1-t)*t*p1.x + 3*(1-t)*t*t*p2.x + t*t*t*p3.x;
			cd.y = (1-t)*(1-t)*(1-t)*p0.y + 3*(1-t)*(1-t)*t*p1.y + 3*(1-t)*t*t*p2.y + t*t*t*p3.y;

			cds.add(cd);
		}
	}

	LineString* pString = GeometryFactory::getDefaultInstance()->createLineString(cds);

	return (Geometry*)pString;
}
/*public*/
void
OffsetCurveBuilder::getSingleSidedLineCurve(const CoordinateSequence* inputPts, 
   double distance, vector<CoordinateSequence*>& lineList, bool leftSide,
   bool rightSide)
{
   // A zero or negative width buffer of a line/point is empty.
   if ( distance <= 0.0 ) return ;

   init( distance ) ;

   if ( inputPts->getSize() < 2 )
   {
      // No cap, so just return.
      return ;
   }
   else
   {
      computeLineBufferCurve( *inputPts ) ;
   }

   // NOTE: we take ownership of lineCoord here ...
   std::auto_ptr<CoordinateSequence> lineCoord (vertexList->getCoordinates());

   // [strk] Oct 1, 2009
   // Left side:  index [n-1] to [endCapIndex]
   // Right side: index [endCapIndex+1] to [n-2]
   // Where n is the last index (size-1).
   int n = lineCoord->size() - 1 ;

   // Add the left side curve to the line list.
   if ( leftSide )
   {
      CoordinateArraySequence* coordSeq = new CoordinateArraySequence() ;
      //coordSeq->add( ( *lineCoord )[n-2] ) ;
      coordSeq->add( ( *lineCoord )[n-1] ) ;
      for ( int i = 0 ; i <= endCapIndex ; ++i )
      {
         coordSeq->add( ( *lineCoord )[i] ) ;
      }
      lineList.push_back( coordSeq ) ;
   }

   // Add the right side curve to the line list.
   if ( rightSide )
   {
      CoordinateArraySequence* coordSeq = new CoordinateArraySequence() ;
      for ( int i = endCapIndex+1 ; i <= n-2 ; ++i )
      {
         coordSeq->add( ( *lineCoord )[i] ) ;
      }

      lineList.push_back( coordSeq ) ;
   }
}
CoordinateArraySequence::CoordinateArraySequence(
    const CoordinateArraySequence &c )
	:
	CoordinateSequence(c),
	vect(new vector<Coordinate>(*(c.vect))),
        dimension(c.getDimension())
{
}
Esempio n. 4
0
void object::test<2>()
{
    Coordinate c1(1.0000000000004998, -7.989685402102996);
    Coordinate c2(10.0, -7.004368924503866);
    Coordinate c3(1.0000000000005, -7.989685402102996);

    CoordinateArraySequence pts;
    pts.add(c1);
    pts.add(c2);
    pts.add(c3);

    int const a = CGAlgorithms::computeOrientation(pts[0], pts[1], pts[2]);
    int const b = CGAlgorithms::computeOrientation(pts[0], pts[1], pts[2]);
    int const c = CGAlgorithms::computeOrientation(pts[0], pts[1], pts[2]);

    ensure_equals( a, b );
    ensure_equals( a, c );
}
    void object::test<16>()
    {
		using geos::geom::Coordinate;
		using geos::geom::CoordinateArraySequence;

		// Create empty sequence to fill with coordinates
		CoordinateArraySequence sequence;
		
		sequence.add(Coordinate(0,0)); 
		sequence.add(Coordinate(1,1)); 
		sequence.add(Coordinate(2,2)); 
		
		ensure_equals( sequence.size(), std::size_t(3));

		sequence.add(0, Coordinate(4,4), false); // don't alow repeated
		ensure_equals( sequence.size(), std::size_t(4) );
		ensure_equals( sequence.getAt(0).x, std::size_t(4) );

		// do not allow repeated
		sequence.add(0, Coordinate(4,4), false); 
		ensure_equals( sequence.size(), std::size_t(4) );

		// allow repeated
		sequence.add(0, Coordinate(4,4), true); 
		ensure_equals( sequence.size(), std::size_t(5) );

		// Now looks like this: 4,4,0,1,2
		// we'll add at position 4 a 2 (equals to the one after)
		sequence.add(4, Coordinate(2,2), false); 
		ensure_equals( sequence.size(), std::size_t(5) );

		// we'll add at position 4 a 1 (equals to the one before)
		sequence.add(4, Coordinate(1,1), false); 
		ensure_equals( sequence.size(), std::size_t(5) );

		// we'll add at position 4 a 1 (equals to the one before)
		// but allowing duplicates
		sequence.add(4, Coordinate(1,1), true); 
		ensure_equals( sequence.size(), std::size_t(6) );
		ensure_equals( sequence.getAt(3).x, 1 );
		ensure_equals( sequence.getAt(4).x, 1 );
		ensure_equals( sequence.getAt(5).x, 2 );
	}