Example #1
0
bool copy_block(Tile* tiles, const Block* block) {
	const p2i& p = block->position;
	int xp = (p.x - START_X + SQUARE_SIZE / 2) / SQUARE_SIZE;
	int yp = (p.y - START_Y + SQUARE_SIZE / 2) / SQUARE_SIZE;
	if (is_block_available(tiles, xp, yp)) {
		for (int i = 0; i < 4; ++i) {
			int cx = xp + MARK_STEPS[i * 2];
			int cy = yp + MARK_STEPS[i * 2 + 1];
			uint32_t idx = get_tiles_index(cx, cy);
			Tile& t = tiles[idx];
			t.state.set(BIT_MARKED);
			t.color = block->colors[i];
			PointList list;
			check(tiles, cx, cy, -1, list, true);
			list.add(cx, cy);
			if (list.size() > 2) {
				//LOG << "connected";
				t.state.set(BIT_COHERENT);
				for (size_t j = 0; j < list.size(); ++j) {
					const p2i& p = list.get(j);
					//LOG << j << " = " << p.x << " " << p.y;
					set_state(tiles, p.x, p.y, BIT_COHERENT);
				}
			}
		}
		determineEdges(tiles);
		return true;
	}
	else {
		//LOG << "Block is not available";
	}
	return false;
}
bool CollisionManager::isIntersectsPointPolygon(ICollisionHull* point, ICollisionHull* polygon)
{
    PointCollisionHull* pointCH = dynamic_cast<PointCollisionHull*>(point);
    PoligonCollisionHull* poligonCH = dynamic_cast<PoligonCollisionHull*>(polygon);

    Vector3 position = pointCH->getPosition();
    PointList points = poligonCH->getPoints();

    int i0, i1;
    float A, B, C, D;
    Vector3 P0, P1;
    for(int i = 0; i < points.size(); i++)
    {
        i0 = i;
        i1 = (i == (points.size() - 1)) ? 0 : i + 1;

        P0 = points[i0];
        P1 = points[i1];

        A = P0._y - P1._y;
        B = P1._x - P0._x;
        C = (P0._x * P1._y) - (P1._x * P0._y);
        D =  (A * position._x) + (B * position._y) + C;

        if(D > 0)
        {
            return false;
        }
    }

    return true;
}
void computePlanes(const PointList& front, const PointList& back, Polytope::PlaneList& planeList)
{
    for(unsigned int i=0;i<front.size();++i)
    {
        unsigned int i_1 = (i+1)%front.size(); // do the mod to wrap the index round back to the start.
        if (!(front[i].first & front[i_1].first))
        {
            planeList.push_back(Plane(front[i].second,front[i_1].second,back[i].second));
        }
    }
}
void ColoredPolygon::UpdatePoints(const PointList &points)
{
    _dots.resize(points.size());
    for (uint i = 0; i < points.size(); ++i)
    {
        _dots[i].pos = points[i];
    }
    CalcWidthAndHeight();
    GenerateTriangles();
    _dotUnderCursor.clear();
    _selectedDots.clear();
    InitCorners();
}
Example #5
0
void writeSQL(Site_2 site, PointList polygon, char* outdir)
{
  std::cout << "INSERT INTO " << outdir << " (geom, id) VALUES (";
  std::cout << "'POLYGON ((";
  for (int i = 0; i < polygon.size(); i++) {
    Point_2 p = polygon.at(i);
    std::cout << p.x() << " " << p.y();
    if (i < polygon.size() - 1) {
      std::cout << ", ";
    }
  }
  std::cout << "))', " << site.id() << ");" << std::endl;
}
Example #6
0
void handleDual(Hyperbola_segment_2 hs, std::vector<PointList>& polylines)
{
        std::cerr << "hyperbola segment" << std::endl; //hs.draw(str);
        PointList p;
        hs.generate_points(p);
        std::cerr << "# hyperbola points: " << p.size() << std::endl;
        PointList points;
        points.insert(points.end(), p.begin(), p.end());
        polylines.push_back(points);
        for (unsigned int i = 0; i < p.size() - 1; i++) {
          Segment_2 seg(p[i], p[i+1]);
          // doing nothing here
        }
}
Example #7
0
    void draw_hand_trace(sf::RenderWindow& window,
                         const PointList& pointList,
                         const sf::Color& color,
                         const float depthScale)
    {
        if (pointList.size() < 2) { return; }

        const float thickness = 4;
        auto it = pointList.begin();
        astra::Vector2i previousPoint = *it;

        while (it != pointList.end())
        {
            const astra::Vector2i currentPoint = *it;
            ++it;

            const sf::Vector2f p1((previousPoint.x + .5f) * depthScale,
                                  (previousPoint.y + .5f) * depthScale);
            const sf::Vector2f p2((currentPoint.x + .5f) * depthScale,
                                  (currentPoint.y + .5f) * depthScale);
            previousPoint = currentPoint;

            window.draw(sfLine(p1, p2, color, thickness));
        }
    }
Example #8
0
 void Dataset<D, ELEM_TYPE>::load(const PointList& newPoints)
 {
     // Pre-allocate memory in one sys call
     m_points.reserve(m_points.size() + newPoints.size());
     // Append given points to end of current point list
     m_points.insert(m_points.end(), newPoints.begin(), newPoints.end());
 }
ColoredPolygon::ColoredPolygon(const PointList &points)
{
    _dots.resize(points.size());
    for (uint i = 0; i < points.size(); ++i)
    {
        _dots[i].pos = points[i];
    }
    CalcWidthAndHeight();
    GenerateTriangles();
    _mouseDown = false;
    _dotUnderCursor.clear();
    _selectedDots.clear();
    _debugDraw = false;
    InitCorners();
    _color = 0xFFFFFFFF;
}
Example #10
0
    BucketKDTreeNode<D, ELEM_TYPE>::BucketKDTreeNode(
        BucketKDTreeNode<D, ELEM_TYPE>* parent,
        const PointList& points)
    : m_parent(parent), m_totalPoints(points.size()),
      m_isLeaf(true), m_points(points),
      m_leftChild(NULL), m_rightChild(NULL),
      m_cuttingDimension(0), m_cuttingValue(0)
    {

    }
void copyPointListToVertexList(const PointList& in,VertexList& out)
{
    out.reserve(in.size());
    for(PointList::const_iterator itr=in.begin();
        itr!=in.end();
        ++itr)
    {
        out.push_back(itr->second);
    }
}
// compute the volume between the front and back polygons of the occluder/hole.
float computePolytopeVolume(const PointList& front, const PointList& back)
{
    float volume = 0.0f;
    Vec3 frontStart = front[0].second;
    Vec3 backStart = back[0].second;
    for(unsigned int i=1;i<front.size()-1;++i)
    {
        volume += computeVolume(frontStart, front[i].second, front[i+1].second,
                                backStart, back[i].second, back[i+1].second);
    }
    return volume;
}
// clip the convex hull 'in' to plane to generate a clipped convex hull 'out'
// return true if points remain after clipping.
unsigned int clip(const Plane& plane,const PointList& in, PointList& out,unsigned int planeMask)
{
    std::vector<float> distance;
    distance.reserve(in.size());
    for(PointList::const_iterator itr=in.begin();
        itr!=in.end();
        ++itr)
    {
        distance.push_back(plane.distance(itr->second));
    }

    out.clear();

    for(unsigned int i=0;i<in.size();++i)
    {
        unsigned int i_1 = (i+1)%in.size(); // do the mod to wrap the index round back to the start.
        
        if (distance[i]>=0.0f)
        {
            out.push_back(in[i]);
            
            
            if (distance[i_1]<0.0f)
            {
                unsigned int mask = (in[i].first & in[i_1].first) | planeMask;
                float r = distance[i_1]/(distance[i_1]-distance[i]);
                out.push_back(Point(mask,in[i].second*r+in[i_1].second*(1.0f-r)));
            }
        
        }
        else if (distance[i_1]>0.0f)
        {
            unsigned int mask = (in[i].first & in[i_1].first) | planeMask;
            float r = distance[i_1]/(distance[i_1]-distance[i]);
            out.push_back(Point(mask,in[i].second*r+in[i_1].second*(1.0f-r)));
        }
    }
    
    return out.size();
}
Example #14
0
void writeWKT(Site_2 site, PointList polygon, char* outdir)
{
  // open an output file for storing the WKT
  std::stringstream s;
  s << outdir << "/" << site.id() << ".wkt";
  std::string polygonFileName = s.str();
  std::cerr << "filename: " << polygonFileName << std::endl;
  std::ofstream file;
  file.open(polygonFileName.c_str());

  // write WKT file
  file << "POLYGON ((";
  for (int i = 0; i < polygon.size(); i++) {
    Point_2 p = polygon.at(i);
    file << p.x() << " " << p.y();
    if (i < polygon.size() - 1) {
      file << ", ";
    }
  }
  file << "))";
  file.close();
}
Example #15
0
void handleDual(Hyperbola_ray_2 hr, Iso_rectangle_2 crect, std::vector<PointList>& polylines)
{
        std::cerr << "hyperbola ray" << std::endl; // hr.draw(str);
        PointList p;
        hr.generate_points(p);
        PointList points;
        points.insert(points.end(), p.begin(), p.end());
        polylines.push_back(points);
        for (unsigned int i = 0; i < p.size() - 1; i++) {
          Segment_2 seg(p[i], p[i+1]);
          // doing nothing here
        }
}
Example #16
0
 boost::optional<Point> fastFilterPointList(
         const PointList& pointList,
         std::vector<Point>& newPointList) const
 {
     assert(!pointList.empty());
     newPointList.reserve(pointList.size() - 1);
     std::copy(
             ++pointList.begin(),
             pointList.end(),
             std::back_inserter(newPointList)
             );
     return boost::optional<Point>(pointList.front());
 } // fastFilterFunctorList
Example #17
0
void writeGeoJSON(Site_2 site, PointList polygon, char* outdir)
{
  // open an output file for storing the WKT
  std::stringstream s;
  s << outdir << "/" << site.id() << ".geojson";
  std::string polygonFileName = s.str();
  std::cerr << "filename: " << polygonFileName << std::endl;
  std::ofstream file;
  file.open(polygonFileName.c_str());

  // write data
  file << "{\"type\":\"Polygon\",\"coordinates\":[[";
  for (int i = 0; i < polygon.size(); i++) {
    Point_2 p = polygon.at(i);
    file << "[" << p.x() << ", " << p.y() << "]";
    if (i < polygon.size() - 1) {
      file << ", ";
    }
  }
  file << "]]}";
  file.close();
}
Example #18
0
//-----------------------------------------------------------------------------
void CGDrawContext::drawPolygon (const PointList& polygonPointList, const CDrawStyle drawStyle)
{
    if (polygonPointList.size () == 0)
        return;
    CGContextRef context = beginCGContext (true, getDrawMode ().integralMode ());
    if (context)
    {
        CGPathDrawingMode m;
        switch (drawStyle)
        {
        case kDrawFilled :
            m = kCGPathFill;
            break;
        case kDrawFilledAndStroked :
            m = kCGPathFillStroke;
            break;
        default :
            m = kCGPathStroke;
            break;
        }
        applyLineStyle (context);

        CGContextBeginPath (context);
        CGPoint p = CGPointFromCPoint(polygonPointList[0]);
        if (getDrawMode ().integralMode ())
            p = pixelAlligned (p);
        CGContextMoveToPoint (context, p.x, p.y);
        for (uint32_t i = 1; i < polygonPointList.size (); i++)
        {
            p = CGPointFromCPoint (polygonPointList[i]);
            if (getDrawMode ().integralMode ())
                p = pixelAlligned (p);
            CGContextAddLineToPoint (context, p.x, p.y);
        }
        CGContextDrawPath (context, m);
        releaseCGContext (context);
    }
}
Example #19
0
//-----------------------------------------------------------------------------
void D2DDrawContext::drawPolygon (const PointList& polygonPointList, const CDrawStyle drawStyle)
{
	if (renderTarget == 0 || polygonPointList.size () == 0)
		return;
	D2DApplyClip ac (this);
	if (ac.isEmpty ())
		return;

	D2DGraphicsPath path;
	path.beginSubpath (polygonPointList[0]);
	for (uint32_t i = 1; i < polygonPointList.size (); ++i)
	{
		path.addLine (polygonPointList[i]);
	}
	if (drawStyle == kDrawFilled || drawStyle == kDrawFilledAndStroked)
	{
		drawGraphicsPath (&path, kPathFilled);
	}
	if (drawStyle == kDrawStroked || drawStyle == kDrawFilledAndStroked)
	{
		drawGraphicsPath (&path, kPathStroked);
	}
}
void Init()
{
	gInterList.clear();
	GenerateConvex(gN,200,Point2D(200,200),gP);
	GenerateConvex(gM,200,Point2D(350,200),gQ);

	Point2D point;
	int i, j;
	for( i = 0 ; i < gN ; i++ )
		for( j = 0 ; j < gM ; j++ )
		{
			if( SegInterSeg(gP[i],gP[Next(i,gN)],gQ[j],gQ[Next(j,gM)],point) )
				printf("(%d,%d)\n",i,j);
		}

		ConvexInterConvex(gP,gN,gQ,gM,gInterList);
		printf("%d\n",gInterList.size());
}
Example #21
0
 Node<Key, T> buildNode(
     const typename NodeTypes<Key, T>::ValueList& valueList,
     const PointList& pointList)
 {
     minLength_ = pointList.size();
     Node<Key, T> result;
     {
         util::ThreadPoolRunner runner(threadPool_);
         doBuildNode<Key, T>(
                 valueList,
                 pointList,
                 maxDepth_,
                 false,
                 State(),
                 result);
     }
     return result;
 }
Example #22
0
void Surface::MultiBlit
(
    const Surface      &surf,
    const PointList    &p,
    const RectList     &r,
    const Surf::BlitFX &fx
)
{
    int ir, rsize = r.size();
    int ip, psize = p.size();
    for( ir=0, ip=0; ir!=rsize && ip!=psize; ++ir, ++ip )
    {
        if (!r[ir]) continue;

        Pos ps = p[ip]; Rect rc = r[ir];
        Blit( ps.x, ps.y , surf, rc, fx );
    }
}
Example #23
0
	void IndexPseudoPyramidTree::rebuild()
	{
		// Store old points to re-insert into structure
		PointList oldPoints = points;
		// Clear all data from structure
		points.clear();
		pointSums.clear();
		hashMap.clear();
		// Insert non-marked pooints into structure incrementally
		for (unsigned int i = 0; (i < oldPoints.size()); i++)
		{
			// Only insert point if its old index has NOT been marked as empty
			if (std::find(emptyElementIndices.begin(), emptyElementIndices.end(), i) == emptyElementIndices.end())
				insert(oldPoints[i]);
		}
		// Now clear the marked elements list
		emptyElementIndices.clear();
	}
// clip the convex hull 'in' to planeList to generate a clipped convex hull 'out'
// return true if points remain after clipping.
unsigned int clip(const Polytope::PlaneList& planeList,const VertexList& vin,PointList& out)
{
    PointList in;
    copyVertexListToPointList(vin,in);
    
    unsigned int planeMask = 0x1;
    for(Polytope::PlaneList::const_iterator itr=planeList.begin();
        itr!=planeList.end();
        ++itr)
    {
        if (!clip(*itr,in,out,planeMask)) return false;
        in.swap(out);
        planeMask <<= 1;
    }

    in.swap(out);

    return out.size();
}
 void modify_geometry(int obj, Scene& scene, GeometryList& out)
 {
   PointList* points = out.writable_points(obj);
   const unsigned n = points->size();
   // Transform points:
   if (swap) {
     // POW
     for (unsigned i = 0; i < n; i++) {
       Vector3& v = (*points)[i];
       if (clamp_black) {
         if (v.x <= 0.0f)
           v.x = 0;
         else
           v.x = pow(v.x, log.x);
         if (v.y <= 0.0f)
           v.y = 0;
         else
           v.y = pow(v.y, log.y);
         if (v.z <= 0.0f)
           v.z = 0;
         else
           v.z = pow(v.z, log.z);
       }
       else {
         v.x = (v.x > 0.0f) ? pow(v.x, log.x) : -pow(-v.x, log.x);
         v.y = (v.y > 0.0f) ? pow(v.y, log.y) : -pow(-v.y, log.y);
         v.z = (v.z > 0.0f) ? pow(v.z, log.z) : -pow(-v.z, log.z);
       }
     }
   }
   else {
     // LOG
     for (unsigned i = 0; i < n; i++) {
       Vector3& v = (*points)[i];
       v.x = pow(log.x, v.x) - 1.0f;
       v.y = pow(log.y, v.y) - 1.0f;
       v.z = pow(log.z, v.z) - 1.0f;
     }
   }
 }
int main()
{
	PointList points;

	// Generate points
	points.resize(sc_pointCount);
	for (unsigned int i = 0; i < points.size(); ++i) {
		points[i] = Point(
			rand()%(maxCoordinate*2) - maxCoordinate,
			rand()%(maxCoordinate*2) - maxCoordinate);
	}

	findClosestPoints(points, sc_numPointsToFind);

	// Print out results
	for (unsigned int i = 0; i < sc_numPointsToFind; ++i) {
		Point& point = points[i];
		std::cout << "(" << point.x << "," << point.y << ") ";
	}

	return 0;
}
// Finlds numPoints elements closest to zero and rearranges them to the 
// beginning of |points|
void findClosestPoints(PointList& points, int numPoints) {
	int startPos = 0;
	int endPos = points.size() - 1;
	
	// Value to use for sorting, all smaller values go to left, all
	// bigger ones go to right
	int value = points[0].distance; 
	while(startPos != numPoints) {
		const int pos = SortOut(points, value, startPos, endPos);
		std::cout << "( " << startPos << " - " << endPos << " )" << std::endl;
		
		if (pos > numPoints) {
			endPos = pos - 1;
			value = points[endPos].distance;
		} else if (pos < numPoints) {
			startPos = pos + 1;
			value = points[startPos].distance;
		} else { // pos == numPoints
			return;
		}
	}
}
Example #28
0
// ============================================================================
// Draw points and curves
// ============================================================================
void CBezierWnd::Draw()
{
    // Draw control point handles and labels
  for ( PointSetIt i = m_Points.begin(); i != m_Points.end(); ++i )
  {
    DrawHandle( *i );
    DrawLabel( *i );
  }

  if ( m_Points.size() < 3)
    return;

    // Draw curve
  PointList lPoints;
  for ( PointSetIt i = m_Points.begin(); i != m_Points.end(); ++i )
    lPoints.push_back( *i );

  CPoint2D p2DStart =  *m_Points.begin();
  float fStep = 1.f / ( 10.f * ( float ) lPoints.size() );
  for ( float i = 0.f; i <= 1.f; i+= fStep )
  {

    CPoint2D p2D = GetBezierPoint( lPoints, i );
    DrawLine( p2DStart, p2D );
    p2DStart = p2D;
  }
  DrawLine( p2DStart, lPoints.back() );

    // Draw control polygon
  if ( m_bDrawPoly )
  {
    PointSetIt i = m_Points.begin(), iPrev = i++;
    do {
      DrawLine( *iPrev, *i );
      iPrev = i++;
    } while ( i != m_Points.end() );
  }
}
Example #29
0
bool CollisionManager::isIntersectsCirclePolygon(ICollisionHull* circle, ICollisionHull* polygon)
{
    CircleCollisionHull* circleCH = dynamic_cast<CircleCollisionHull*>(circle);
    PoligonCollisionHull* poligonCH = dynamic_cast<PoligonCollisionHull*>(polygon);

    Vector3 position = circleCH->getPosition();
    float radius = circleCH->getRadius();
    PointList points = poligonCH->getPoints();

    Vector3 dv;
    float distance;
    for(int i = 0; i < points.size(); i++)
    {
        dv = position - points[i];
        distance = dv.length();
        if(distance <= radius)
        {
            return true;
        }
    }

    return false;
}
//-----------------------------------------------------------------------------
void GdiplusDrawContext::drawPolygon (const PointList& polygonPointList, const CDrawStyle drawStyle)
{
	if (polygonPointList.size () == 0)
		return;

	GdiplusDrawScope drawScope (pGraphics, currentState.clipRect, getCurrentTransform ());

	Gdiplus::PointF points[30];
	Gdiplus::PointF* polyPoints;
	bool allocated = false;
	if (polygonPointList.size () > 30)
	{
		polyPoints = new Gdiplus::PointF[polygonPointList.size ()];
		allocated = true;
	}
	else
		polyPoints = points;
	
	for (uint32_t i = 0; i < polygonPointList.size (); i++)
	{
		polyPoints[i].X = (Gdiplus::REAL)(polygonPointList[i].x);
		polyPoints[i].Y = (Gdiplus::REAL)(polygonPointList[i].y);
	}

	if (drawStyle == kDrawFilled || drawStyle == kDrawFilledAndStroked)
		pGraphics->FillPolygon (pBrush, polyPoints, static_cast<INT> (polygonPointList.size ()));
	if (drawStyle == kDrawFilledAndStroked || drawStyle == kDrawStroked)
	{
		pGraphics->TranslateTransform (0.5f, 0.5f);
		pGraphics->DrawPolygon (pPen, polyPoints, static_cast<INT> (polygonPointList.size ()));
		pGraphics->TranslateTransform (-0.5f, -0.5f);
	}

	if (allocated)
		delete[] polyPoints;
}