Example #1
0
TEST(Segment, Intersection_Segment_parallel){
    vector<Point> ans;
    vector<Point> res = Segment(1,3,3,5).intersection(Segment(2,1,4,3));
    ASSERT_EQ(ans, res);
};
Example #2
0
Router::Router(const Signature& signature,
               const std::unordered_map<std::string, float>& language)
    : m_carrier(*signature.carrier()),
      m_language(language),
      m_value_index(signature.carrier()->item_count()) {
    POMAGMA_INFO("Building router indices");

    for (auto pair : signature.nullary_functions()) {
        const auto& name = pair.first;
        const auto& fun = *pair.second;
        if (m_language.find(name) != m_language.end()) {
            const TypeId type = new_type(NULLARY, name);
            if (Ob val = fun.find()) {
                m_segments.push_back(Segment(type, val));
            }
        }
    }

    for (auto pair : signature.injective_functions()) {
        const auto& name = pair.first;
        const auto& fun = *pair.second;
        if (m_language.find(name) != m_language.end()) {
            const TypeId type = new_type(UNARY, name);
            for (auto iter = fun.iter(); iter.ok(); iter.next()) {
                Ob arg = *iter;
                Ob val = fun.find(arg);
                m_segments.push_back(Segment(type, val, arg));
            }
        }
    }

    for (auto pair : signature.binary_functions()) {
        const auto& name = pair.first;
        const auto& fun = *pair.second;
        if (m_language.find(name) != m_language.end()) {
            const TypeId type = new_type(BINARY, name);
            for (auto iter = m_carrier.iter(); iter.ok(); iter.next()) {
                Ob lhs = *iter;
                for (auto iter = fun.iter_lhs(lhs); iter.ok(); iter.next()) {
                    Ob rhs = *iter;
                    Ob val = fun.find(lhs, rhs);
                    m_segments.push_back(Segment(type, val, lhs, rhs));
                }
            }
        }
    }

    for (auto pair : signature.symmetric_functions()) {
        const auto& name = pair.first;
        const auto& fun = *pair.second;
        if (m_language.find(name) != m_language.end()) {
            const TypeId type = new_type(BINARY, name);
            for (auto iter = m_carrier.iter(); iter.ok(); iter.next()) {
                Ob lhs = *iter;
                for (auto iter = fun.iter_lhs(lhs); iter.ok(); iter.next()) {
                    Ob rhs = *iter;
                    Ob val = fun.find(lhs, rhs);
                    m_segments.push_back(Segment(type, val, lhs, rhs));
                }
            }
        }
    }

    std::sort(m_segments.begin(), m_segments.end());

    // assume all values are reached by at least one segment
    m_value_index.resize(1 + m_carrier.item_count(), 0);
    for (size_t i = 0; i < m_segments.size(); ++i) {
        m_value_index[m_segments[i].val] = i;
    }
}
Example #3
0
int main(int argc, char** argv) {
  srand(time(NULL));  // init rand;

#if PORTAL
  Portal p(Segment(10, 40, 10, 20), Segment(40, 10, 20, 10));
  std::vector<Segment> lines(p.deviateLine(Segment(20, 40, 0, 30)));
  for (const Segment& line: lines)
    std::cerr << line << std::endl;
#endif

#if Thumbnail


  QApplication app(argc, argv);

  PolygonList polygonList;
  //polygonList << poc::Polygon(30, 250, 21, 260, 5);
  poc::Polygon polygon;
  polygon << Point2d(55, 55)
  << Point2d(455, 55)
  << Point2d(455, 455)
  << Point2d(155, 455)
  << Point2d(155, 255)
  << Point2d(255, 255)
  << Point2d(255, 355)
  << Point2d(355, 355)
  << Point2d(355, 155)
  << Point2d(55, 155);
  polygonList << polygon;
  qDebug() << polygonList;
  ThumbnailCreator thumbnailCreator(polygonList);
  QImage thumbnail = thumbnailCreator.makeThumbnail();

  QLabel* label = new QLabel;
  label->setPixmap(QPixmap::fromImage(thumbnail));
  label->show();

  return app.exec();
#endif

#if TESTPOINT
  Test::test<< Point2d();
#endif

#if TESTVECTOR
  Test::testVector2d();
#endif

#if TESTPOLYGON
  Test::testPolygon();
#endif

#if GUI
  QApplication app(argc, argv);

//  QFontDatabase::addApplicationFont("../PieceOfCake/fonts/edosz.ttf");
//  QFontDatabase::addApplicationFont("../PieceOfCake/fonts/watermark.ttf");

  qmlRegisterType<GameInfo>("gameinfo", 1, 0, "GameInfo");
  qmlRegisterType<LevelInfo>("levelinfo", 1, 0, "LevelInfo");

  MainWindow window;
  window.show();

  return app.exec();
#endif

#if QML
  QGuiApplication app(argc, argv);

  QQmlApplicationEngine engine;
  engine.load(QUrl(QStringLiteral("qrc:/main.qml")));

  return app.exec();
#endif

#if GNUPLOT
  // poc::Polygon polygon;
  // polygon << << Point2d() << << Point2d(0, 1) << << Point2d(1, 1) << << Point2d(1);

  poc::Polygon polygon(0, 100, 0, 100, 7);
  //    std::vector<Point2d> vertices = polygon.getVertices();
  //    for (unsigned int k = 0; k < vertices.size(); ++k)
  //        std::cerr << vertices.at(k).getX() << " " << vertices.at(k).getY() << " " << -10 << std::endl;

  float size = 300;
  float delta = 10;
  int max = size/delta;

  float** matrix = polygon.surface(size, delta);
  for (int i = 0; i < max; ++i) {
    for (int j = 0; j < max; ++j) {
      std::cerr << i << " " << j << " " << matrix[i][j] << std::endl;
    }
    delete[] matrix[i];
  }
  delete[] matrix;

#endif

#if XML
  Test::testXML();
#else
  return EXIT_SUCCESS;
#endif
}
Example #4
0
void
Canvas::DrawSegment(int x, int y, unsigned radius,
                    Angle start, Angle end, bool horizon)
{
  Segment(*this, x, y, radius, start, end, horizon);
}
Example #5
0
//
// THIS FUNCTION IS THREAD SAFE, but not using optimized clipping
//
void MapWindow::DrawTaskPicto(HDC hdc,int TaskIdx, RECT rc, double fScaleFact)
{
int center_x = (rc.right-rc.left)/2;
int center_y = (rc.bottom-rc.top)/2;
int SecType = SectorType;
int width = center_x-2;
HPEN oldpen = 0;
HBRUSH oldbrush = 0;
if(AATEnabled)
  oldbrush = (HBRUSH) SelectObject(hdc, LKBrush_LightGrey);
else
  oldbrush = (HBRUSH) SelectObject(hdc, GetStockObject(HOLLOW_BRUSH));

oldpen = (HPEN) SelectObject(hdc, hpStartFinishThick);
int finish=0;

while( ValidTaskPoint(finish))
 finish++;
finish--;

if(center_y < width)
  width = center_y-2;

POINT startfinishline[2] = {{0,-width/ScreenScale},
                            {0,width/ScreenScale}};

POINT track[3] = {{0,-width/5/ScreenScale},
                  {width/2/ScreenScale,0},
                  {0,width/5/ScreenScale}};
if(TaskIdx == finish)
{
  track[0].x = -width/2/ScreenScale; track[0].y= -width/5/ScreenScale;
  track[1].x = 0 ; track[1].y= 0;
  track[2].x = -width/2/ScreenScale ; track[2].y= width/5/ScreenScale;
}

LockTaskData(); // protect from external task changes
double StartRadial = Task[TaskIdx].AATStartRadial;
double FinishRadial = Task[TaskIdx].AATFinishRadial;

if(TaskIdx==0)
{
  FinishRadial = Task[TaskIdx].AATStartRadial;
  StartRadial = Task[TaskIdx].AATFinishRadial;
}

double LineBrg;
double SecRadius;
GetTaskSectorParameter( TaskIdx, &SecType,&SecRadius);

    switch (SecType)
    {
        case CIRCLE:
            CircleNoCliping(hdc,
             center_x,
             center_y,
             width-2, rc, true);
            break;
        case SECTOR:
            Segment(hdc,
             center_x,
             center_y, width, rc,
             StartRadial,
             FinishRadial);
            break;
        case DAe:
            if (!AATEnabled) { // this Type exist only if not AAT task
                // JMW added german rules
                CircleNoCliping(hdc,
                 center_x,
                 center_y,
                 width/8, rc, true);

                Segment(hdc,
                 center_x,
                 center_y, width, rc,
                 StartRadial,
                 FinishRadial);
            }
            break;
       default:
       case LINE:
            if (TaskIdx == 0) {
                LineBrg = Task[TaskIdx].OutBound-90;
            } else if (TaskIdx == finish) {
                LineBrg = Task[TaskIdx].InBound-90;
            } else {
                LineBrg = Task[TaskIdx].Bisector;
            }
            threadsafePolygonRotateShift(startfinishline, 2, center_x, center_y, LineBrg);
            Polygon(hdc, startfinishline, 2);
            if ((TaskIdx == 0) || (TaskIdx == finish)) {
                threadsafePolygonRotateShift(track, 3, center_x, center_y, LineBrg);
                Polygon(hdc, track, 3);
            }
       break;
        case CONE:
            if (DoOptimizeRoute()) {

                int radius = width-2;
                CircleNoCliping(hdc, center_x, center_y, radius, rc, true);
                HPEN prevPen = (HPEN)::SelectObject(hdc, hpTerrainLine);
                for( int i = 1; i < 4 && radius > (width/5); ++i) {
                    CircleNoCliping(hdc, center_x, center_y, radius -= width/5, rc, true);
                }
                ::SelectObject(hdc, prevPen);
            }
            break;
    }
UnlockTaskData();

SelectObject(hdc, oldpen);
SelectObject(hdc, oldbrush);
}
Example #6
0
	void operator() (Drawable & drawable)
	{
		if (!drawable.GetDrawEnable())
			return;

		assert(drawable.GetVertArray());
		const VertexArray & va = *drawable.GetVertArray();
		const VertexFormat::Enum vf = va.GetVertexFormat();
		const unsigned int vsize = VertexFormat::Get(vf).stride / sizeof(float);
		const unsigned int vcount = va.GetNumVertices();
		const unsigned int icount = va.GetNumIndices();

		// FIXME: text drawables can contain empty vertex arrays,
		// they should be culled before getting here
		if (vcount == 0)
		{
			// reset segment as we might miss text drawable vcount change
			// happens with Tracks/Cars scroll onfocus tooltip update
			// need to investigate this
			if (drawable.GetVertexBufferSegment().age)
				drawable.SetVertexBufferSegment(Segment());
			return;
		}

		// get dynamic vertex data object (first object in the vector)
		const unsigned int obindex = 0;
		assert(!ctx.objects[vf].empty());
		Object & ob = ctx.objects[vf][obindex];

		// gen object buffers
		if (ob.vbuffer == 0)
		{
			glGenBuffers(1, &ob.ibuffer);
			glGenBuffers(1, &ob.vbuffer);
			if (ctx.use_vao)
			{
				glGenVertexArrays(1, &ob.varray);
				if (ob.varray == 0)
					ctx.use_vao = ctx.good_vao = false;
			}
			ob.vformat = vf;
		}

		// set segment
		Segment sg;
		sg.ioffset = ob.icount * sizeof(unsigned int);
		sg.icount = icount;
		sg.voffset = ob.vcount;
		sg.vcount = vcount;
		sg.vbuffer = ob.varray ? ob.varray : ob.vbuffer;
		sg.vformat = vf;
		sg.object = obindex;
		sg.age = ctx.age_dynamic;
		drawable.SetVertexBufferSegment(sg);

		// upload data into staging buffers
		std::vector<unsigned int> & index_buffer = ctx.staging_index_buffer[vf];
		std::vector<float> & vertex_buffer = ctx.staging_vertex_buffer[vf];
		const unsigned int ibn = (ob.icount + icount);
		const unsigned int vbn = (ob.vcount + vcount) * vsize;
		if (index_buffer.size() < ibn)
		{
			const unsigned int ibmin = min_dynamic_index_buffer_size / sizeof(unsigned int);
			index_buffer.resize(std::max(ibn, ibmin));
		}
		if (vertex_buffer.size() < vbn)
		{
			const unsigned int vbmin = min_dynamic_vertex_buffer_size / sizeof(float);
			vertex_buffer.resize(std::max(vbn, vbmin));
		}
		ob.icount = WriteIndices(va, ob.icount, ob.vcount, index_buffer);
		ob.vcount = WriteVertices(va, ob.vcount, vsize, vertex_buffer);
	}
Example #7
0
LPP* MorpionLPP::getLPP()
{
    setComment(gameId());

    // each possible move is a structural variable
    // our goal is to maximize sum over all variables

    for (const Move& m: b.getMoveList()) {        
        std::string v_name = to_string(m);

        setVariableBounds(v_name, 0.0, 1.0);
        getObjective().push_back(std::pair<std::string, double>(v_name, 1.0));
        
        // Constraint for exact problems.
        //
        //   mv_ variables are either 0 or 1 (i.e. the move is either played or not)

        if (getFlag("exact") || getFlag("binary_moves")) {
            setVariableBoolean(v_name, true);
        }
    }

    // each segment gives us constraints:
    // (1) if the segment is placed in the starting position
    //    (a) sum of weights of moves that place this segment <= 0
    //    (b) 1 - sum of weights of moves that remove this segment >= 0
    //        i.e. sum of weights of moves that remove this segment <= 1
    // (2) if the segment is not placed in the starting position
    //    (a) sum of weights of moves that place this segment <= 1
    //    (b) sum of weights of moves that place this segment
    //          - sum of weights of moves that remove this segment >= 0
            
    for (const Segment& s: b.getSegmentList()) {
        int x = s.first.x;
        int y = s.first.y;
        int d = s.second;

        std::string constr_name = "segment_" + to_string(x) + "_" + to_string(y) + "_" + to_string(d);

        if (b.hasDot(Dot(x,y))) {
            // (1a)
            {
                Constraint constr;
        
                for (Move& pl: b.getMovesPlacingSegment(s)) {
                    constr.addVariable(to_string(pl), 1.0);
                }
                constr.setName("r1a_" + constr_name);
                constr.setType(Constraint::LT);
                constr.setBound(0.0);
                addConstraint(constr);
            }
            // (1b)
            {
                Constraint constr;
        
                for (Move& rm: b.getMovesRemovingSegment(s)) {
                    constr.addVariable(to_string(rm), 1.0);
                }
                constr.setName("r1b_" + constr_name);
                constr.setType(Constraint::LT);
                constr.setBound(1.0);
                addConstraint(constr);
            }                        
        } else {
            // (2a)
            {
                Constraint constr;
        
                for (Move& pl: b.getMovesPlacingSegment(s)) {
                    constr.addVariable(to_string(pl), 1.0);
                }
                constr.setName("r2a_" + constr_name);
                constr.setType(Constraint::LT);
                constr.setBound(1.0);
                addConstraint(constr);
            }
            // (2b)
            {
                Constraint constr;

                for (Move& pl: b.getMovesPlacingSegment(s)) {
                    constr.addVariable(to_string(pl), 1.0);
                }
                for (Move& rm: b.getMovesRemovingSegment(s)) {
                    constr.addVariable(to_string(rm), -1.0);
                }
                constr.setName("r2b_" + constr_name);
                constr.setType(Constraint::GT);
                constr.setBound(0.0);      
                    
                addConstraint(constr);          
            }
        }        
    }

    // EXTRA CONSTRAINTS:
    //
    // for each move m:
    //   for each dot d required by m:
    //     for each move n placing d that is consistent with m:
    //       weight_m <= sum of weights of n's

    if (getFlag("extra")) {
        for (const Move& m: b.getMoveList()) {
            std::string constr_name = "_" + to_string(m);
        
            for (const Dot& d: m.requiredDots(b.getVariant())) {
                if (b.hasDot(d)) continue;
                
                Constraint constr;
                
                for (const Move& n: b.getMovesPlacingSegment(Segment(d,0))) {
                    if (m.consistentWith(n,b.getVariant())) {
                        constr.addVariable(to_string(n), -1.0);
                    }
                }
                constr.addVariable(to_string(m), 1.0);
                
                constr.setName("extra_" + to_string(d) + constr_name);
                constr.setType(Constraint::LT);
                constr.setBound(0.0);
                
                addConstraint(constr);
            }
        }
    }
    
    // Disallow cycles of length 3 from the solution.
    // Improves fuzzy solutions
    
    if (getFlag("short-cycles")) {         
        for (const Segment& s: b.getSegmentList()) {
        
            int d = s.second;
            
            if (d % 2 == 1) continue;
            
            addConstraints(createCycleConstraints(s, d + 2, d + 5));
            addConstraints(createCycleConstraints(s, d + 6, d + 1));                
        }            
    }
    
    // Constraints for acyclic problems (explanation makes sense for exact problems):
    //
    // OBSOLETE
    //
    // 1. Each move mv_* has accompanying order variable order_*
    // 2. Move that is not picked has always order 0, 
    //    move that is picked has order between 1 and 675
    // 
    // It is accomplished with the condition:
    //      mv_ <= order_ <= 675 * mv_
    //
    // 3. Assume that mv_1 removes segment s and mv_2 places segment s (mv_1 != mv_2). 
    //    Then
    //      order_1 + (1 - mv_1) * 1000 >= order_2 + 1
    //
    //    The (1-mv_1)*1000 term assures that the condition is not enforced
    //      for moves that are not picked (i.e. have mv_1 = 0)
            
    if (getFlag("acyclic")) {
        throw std::string("not implemented");
    }

    // Constraints for symmetric problems.
    //
    // Moves that are symmetric by central symmetry
    //   with center at ref + (1.5,1.5) have to have equal weights
    
    if (getFlag("symmetric")) {
        for (const Move&m: b.getMoveList()) {
            Move sm = b.centerSymmetry(m);
            
            Constraint c;
            
            c.addVariable(to_string(m), 1.0);
            c.addVariable(to_string(sm), -1.0);
            c.setType(Constraint::EQ);
            c.setBound(0.0);
            c.setName("sym_" + to_string(m));
            
            addConstraint(c);
        }
    }

    // dot-acyclic - better implementation of acyclic problems

    // dots that are not placed have dot_ variable equal to 0
    // this is important for --hull option
    // use this not only for dot-acyclic problems
    
    for (const Dot& d: b.getDotList())
    {
        if (b.hasDot(d)) continue;
        
        Constraint c;
        
        c.setName("dotmove_" + to_string(d));
        
        c.addVariable("dot_" + to_string(d), 1.0);
        
        for (const Move& m: b.getMovesPlacingDot(d)) {
            c.addVariable(to_string(m), -b.bound());
        }
        c.setType(Constraint::LT);
        c.setBound(0.0);
        addConstraint(c);                    
    }
    
    if (getFlag("dot-acyclic")) {
        for (int x = 0; x < b.getWidth(); x++) {
            for (int y= 0; y < b.getHeight(); y++) {
                if (b.infeasibleDot(Dot(x,y)) || b.hasDot(Dot(x,y))) continue;
                
                setVariableBounds("dot_" + to_string(Dot(x,y)), 0, b.bound());

                if (getFlag("symmetric")) {
                    Constraint c;
                    
                    if (b.infeasibleDot(b.centerSymmetry(Dot(x,y)))) continue;
                    
                    c.setName("dotsym_");
                    c.addVariable("dot_" + to_string(Dot(x,y)), 1.0);
                    c.addVariable("dot_" + to_string(b.centerSymmetry(Dot(x,y))), -1.0);
                    c.setType(Constraint::EQ);
                    c.setBound(0.0);
                    addConstraint(c);
                }                
            }
        }
        
        for (const Move& m: b.getMoveList()) {
            for (const Dot& rq: m.requiredDots(b.getVariant())) {
                if (b.hasDot(rq)) continue;
                
                Constraint c;
                
                // dot_placed >= dot_required + 1 - (1 - m) * bound
                // i.e. dot_placed - dot_required - bound * m >= 1 - bound
                
                c.setName("dot_");
                c.addVariable("dot_" + to_string(m.placedDot()), 1.0);
                c.addVariable("dot_" + to_string(rq), -1.0);
                c.addVariable(to_string(m), -b.bound());
                c.setBound(1 - b.bound());
                c.setType(Constraint::GT);
                
                addConstraint(c);
            }
        }      
    }

    // Constraints that enforce that the board (if it is rectangle) is 
    // the convex hull of the solution
    if (getFlag("rhull")) {
        // right side
        addConstraint(getSideConstraint(1,0,true));        
        // left side
        addConstraint(getSideConstraint(1,0,false));
        // top side
        addConstraint(getSideConstraint(0,1,true));
        // bottom side
        addConstraint(getSideConstraint(0,1,false));        
    }
    
    // Constraints that enforce that the board (if it is octagon) is 
    // the convex hull of the solution

    if (getFlag("hull")) {
        // right side
        addConstraint(getSideConstraint(1,0,true));        
        // left side
        addConstraint(getSideConstraint(1,0,false));
        // lower right side
        addConstraint(getSideConstraint(1,-1,false));
        // upper left side
        addConstraint(getSideConstraint(1,-1,true));
        // top side
        addConstraint(getSideConstraint(0,1,true));
        // bottom side
        addConstraint(getSideConstraint(0,1,false));
        // lower left side
        addConstraint(getSideConstraint(1,1,false));
        // upper right side
        addConstraint(getSideConstraint(1,1,true));
    }
            
    return this;
}
Example #8
0
/*GetALine follow squares intersecting the segment sg, until it reaches : 
-the border of the board, 
-an obstacle or 
-a square that insects the segment only one time (the segment can't go beyond it to neigbooring squares) 
*/
void SquareLine::GetALine()
{
	vector2d l_cornerspos[4]; //corners of a square
	board->GetSquareCornersInLogPx(s_cur,l_cornerspos);
	Segment sg2;
	int i,intersection_value ;
	vector2d ipoint;

	//foreach segment in the square, see intersection;
	for(i=0; i<4; i++)
	{
		if(i+1 == 4)
			sg2=Segment(l_cornerspos[i],l_cornerspos[0]);
		else
			sg2=Segment(l_cornerspos[i],l_cornerspos[i+1]);
		
		intersection_value = lines_intersect(sg,sg2, ipoint);

		ipoint.setint();

		if(intersection_value == 1 && ! (ipoint== p_lastipoint) )
		{
			if( ipoint == l_cornerspos[i] || ipoint == l_cornerspos[i+1])
			{
				vector2d g = sg.p1-ipoint;
				Square s;

				if(g.x>0)
				{
					if(g.y>0)
					{
						s=s_cur+vector2d(1,0);
						if(board->GetContentAt(s) ==  e_obstacle)
						{
							s=s_cur+vector2d(0,1);
							if(board->GetContentAt(s) ==  e_obstacle)
							{
								return;
							}
							else
							{
								pl_squares->push_back(s);
							}
						}
						else
						{
							pl_squares->push_back(s);
						}

						s_cur=s_cur+vector2d(1,1);
					}
					else if(g.y<0)
					{
						s=s_cur+vector2d(1,0);
						if(board->GetContentAt(s) ==  e_obstacle)
						{
							s=s_cur+vector2d(0,-1);
							if(board->GetContentAt(s) ==  e_obstacle)
							{
								return;
							}
							else
							{
								pl_squares->push_back(s);
							}
						}
						else
						{
							pl_squares->push_back(s);
						}

						s_cur=s_cur+vector2d(1,-1);
					}
					else
						assert(0); //this means that the line coincides with the x-axis. and this is not possible since the destination point is a square center.
				}
				else if(g.x<0)
				{
					if(g.y>0)
					{
						s=s_cur+vector2d(-1,0);
						if(board->GetContentAt(s) ==  e_obstacle)
						{
							s=s_cur+vector2d(0,1);
							if(board->GetContentAt(s) ==  e_obstacle)
							{
								return;
							}
							else
							{
								pl_squares->push_back(s);
							}
						}
						else
						{
							pl_squares->push_back(s);
						}
						s_cur=s_cur+vector2d(-1,1);
					}
					else if(g.y<0)
					{
						s=s_cur+vector2d(-1,0);
						if(board->GetContentAt(s) ==  e_obstacle)
						{
							s=s_cur+vector2d(0,-1);
							if(board->GetContentAt(s) ==  e_obstacle)
							{
								return;
							}
							else
							{
								pl_squares->push_back(s);
							}
						}
						else
						{
							pl_squares->push_back(s);
						}
						s_cur=s_cur+vector2d(-1,-1);
					}
					else
						assert(0); //this means that the line coincides with the x-axis. and this is not possible since the destination point is a square center.
				}
				else
					assert(0); //this means that the line coincides with the y-axis. and this is not possible since the destination point is a square center.
			}
			else if(i==0)
			{
				s_cur=s_cur+vector2d(0,-1);
			}
			else if(i==1)
			{
				s_cur=s_cur+vector2d(1,0);
			}
			else if(i==2)
			{
				s_cur=s_cur+vector2d(0,1);
			}
			else
			{
				s_cur=s_cur+vector2d(-1,0);
			}

			p_lastipoint=ipoint;

			break;
		}
	}

	if(!NotOutOfBoard(s_cur) || board->GetContentAt(s_cur) ==  e_obstacle)
	{
		return;
	}

	if(i==4) 
	{//when i == 4, it's the last square touched by the segment sg.
		return;
	}

	pl_squares->push_back(s_cur);
	
	GetALine();

}
Example #9
0
//gets the square next to s_from, in the direction of s_to.
//used by FindARefuge to have a square next to an obstacle.
Square SquareLine::GetAdjacentSquareTowards(Square s_from, Square s_to, Board * board)
{
	vector2d l_cornerspos[4]; //corners of a square
	Square	s_ret=s_from;
	Segment sg2;

	int i,intersection_value ;
	vector2d ipoint;


	board->GetSquareCornersInLogPx(s_from,l_cornerspos);

	
	Segment sg(board->GetCenterInPx(s_from),board->GetCenterInPx(s_to));

	//foreach segment in the square, see intersection;
	for(i=0; i<4; i++)
	{
		if(i+1 == 4)
			sg2=Segment(l_cornerspos[i],l_cornerspos[0]);
		else
			sg2=Segment(l_cornerspos[i],l_cornerspos[i+1]);
		
		intersection_value = lines_intersect(sg,sg2, ipoint);

		ipoint.setint();

		if(intersection_value == 1)
		{
			if( ipoint == l_cornerspos[i] || ipoint == l_cornerspos[i+1])
			{
				vector2d g = sg.p1-ipoint;

				if(g.x>0)
				{
					if(g.y>0)
					{
						s_ret=s_ret+vector2d(1,1);
					}
					else if(g.y<0)
					{
						s_ret=s_ret+vector2d(1,-1);
					}
					else
						assert(0); //this means that the line coincides with the x-axis. and this is not possible since the destination point is a square center.
				}
				else if(g.x<0)
				{
					if(g.y>0)
					{
						s_ret=s_ret+vector2d(-1,1);
					}
					else if(g.y<0)
					{
						s_ret=s_ret+vector2d(-1,-1);
					}
					else
						assert(0); //this means that the line coincides with the x-axis. and this is not possible since the destination point is a square center.
				}
				else
					assert(0); //this means that the line coincides with the y-axis. and this is not possible since the destination point is a square center.
			}
			else if(i==0)
			{
				s_ret=s_ret+vector2d(0,-1);
			}
			else if(i==1)
			{
				s_ret=s_ret+vector2d(1,0);
			}
			else if(i==2)
			{
				s_ret=s_ret+vector2d(0,1);
			}
			else
			{
				s_ret=s_ret+vector2d(-1,0);
			}


			break;
		}
	}

	return s_ret;
}
Example #10
0
TEST(Circle, Intersection_Segment_1){
    vector<Point> ans = { Point(sqrt(2.),sqrt(2.)) };
    ASSERT_EQ(ans, Circle(Point(0,0),2).intersection(Segment(0,0,3,3)));
};
Example #11
0
TEST(Circle, Intersection_Segment_ox_2){
    vector<Point> ans = { Point(sqrt(2.),sqrt(2.)), Point(-sqrt(2.),sqrt(2.)) };
    ASSERT_EQ(ans, Circle(Point(4,4),2).intersection(Segment(-3,sqrt(2.),3,sqrt(2.))));
};
Example #12
0
TEST(Circle, Projection){
    ASSERT_EQ(Segment(2.5,2.5,4.5,4.5), Circle(Point(3,4),(Point(2,3) - Point(3,4)).norm()).projection(Point(5,5)));
};
Example #13
0
TEST(Segment, Projection){
    ASSERT_EQ(Segment(3,3,5,5), Segment(2,4,4,6).projection(Point(7,7)));
};
Example #14
0
TEST(Segment, Intersection_Segment_noIntersection_2){
    vector<Point> ans;
    vector<Point> res = Segment(1,3,3,5).intersection(Segment(4,2,5,1));
    ASSERT_EQ(ans, res);
};
Example #15
0
 static inline Segment construct(
     const point_type& low, const point_type& high) {
   return Segment(low, high);
 }
Example #16
0
bool SquareLine::CanSee()
{
#if defined(_showdebugger_)
//	Debugger::GetInstance().Output("(%d,%d)  ",s_cur.x,s_cur.y);
#endif //defined(_showdebugger_)

	if(s_cur == s_goal)
		return true;
	if(!NotOutOfBoard(s_cur))//IsAValidRefuge can call CanSee with a square out of board. 
		return true;		//if no obstacle can hide the refuge from the borders of the map, the refuge is exposed.
	else if(board->GetContentAt(s_cur) == e_obstacle)
		return false;

	vector2d l_cornerspos[4]; //corners of a square
	board->GetSquareCornersInLogPx(s_cur,l_cornerspos);
	Segment sg2;
	int i,intersection_value ;
	vector2d ipoint;

	//foreach segment in the square, see intersection;
	for(i=0; i<4; i++)
	{
		if(i+1 == 4)
			sg2=Segment(l_cornerspos[i],l_cornerspos[0]);
		else
			sg2=Segment(l_cornerspos[i],l_cornerspos[i+1]);
		
		intersection_value = lines_intersect(sg,sg2, ipoint);

		ipoint.setint();

		if(intersection_value == 1 && ! (ipoint== p_lastipoint) )
		{
			if( ipoint == l_cornerspos[i] || ipoint == l_cornerspos[i+1])
			{
				vector2d g = sg.p1-ipoint;

				if(g.x>0)
				{
					if(g.y>0)
					{
						s_cur=s_cur+vector2d(1,1);
					}
					else if(g.y<0)
					{
						s_cur=s_cur+vector2d(1,-1);
					}
					else
						assert(0); //this means that the line coincides with the x-axis. and this is not possible since the destination point is a square center.
				}
				else if(g.x<0)
				{
					if(g.y>0)
					{
						s_cur=s_cur+vector2d(-1,1);
					}
					else if(g.y<0)
					{
						s_cur=s_cur+vector2d(-1,-1);
					}
					else
						assert(0); //this means that the line coincides with the x-axis. and this is not possible since the destination point is a square center.
				}
				else
					assert(0); //this means that the line coincides with the y-axis. and this is not possible since the destination point is a square center.
			}
			else if(i==0)
			{
				s_cur=s_cur+vector2d(0,-1);
			}
			else if(i==1)
			{
				s_cur=s_cur+vector2d(1,0);
			}
			else if(i==2)
			{
				s_cur=s_cur+vector2d(0,1);
			}
			else
			{
				s_cur=s_cur+vector2d(-1,0);
			}

			p_lastipoint=ipoint;

			break;
		}
	}

	return CanSee();
}
  void ConnectionsPerformanceTest::runSpatialPoolerTest(UInt numCells,
                                                        UInt numInputs,
                                                        UInt w,
                                                        UInt numWinners,
                                                        string label)
  {
    clock_t timer = clock();

    Connections connections(numCells, 1, numInputs);
    Cell cell;
    Segment segment;
    vector<Cell> sdr;
    Activity activity;

    // Initialize

    for (UInt c = 0; c < numCells; c++)
    {
      cell = Cell(c);
      segment = connections.createSegment(c);

      for (UInt i = 0; i < numInputs; i++)
      {
        connections.createSynapse(segment, i, (Permanence)rand()/RAND_MAX);
      }
    }

    checkpoint(timer, label + ": initialize");

    // Learn

    vector<Cell> winnerCells;
    SynapseData synapseData;
    Permanence permanence;

    for (int i = 0; i < 500; i++)
    {
      sdr = randomSDR(numInputs, w);
      activity = connections.computeActivity(sdr, 0.5, 0);
      winnerCells = computeSPWinnerCells(numWinners, activity);

      for (Cell winnerCell : winnerCells)
      {
        segment = Segment(0, winnerCell);

        for (Synapse synapse : connections.synapsesForSegment(segment))
        {
          synapseData = connections.dataForSynapse(synapse);
          permanence = synapseData.permanence;

          if (find(sdr.begin(), sdr.end(), synapseData.presynapticCell) !=
              sdr.end())
          {
            permanence += 0.2;
          }
          else
          {
            permanence -= 0.1;
          }

          permanence = max(permanence, (Permanence)0);
          permanence = min(permanence, (Permanence)1);

          // TODO (Question): Remove synapses with 0 permanence?

          connections.updateSynapsePermanence(synapse, permanence);
        }
      }
    }

    checkpoint(timer, label + ": initialize + learn");

    // Test

    for (int i = 0; i < 500; i++)
    {
      sdr = randomSDR(numInputs, w);
      activity = connections.computeActivity(sdr, 0.5, 0);
      winnerCells = computeSPWinnerCells(numWinners, activity);
    }

    checkpoint(timer, label + ": initialize + learn + test");
  }
Example #18
0
void route_edges2(Layouter &state,plugin& pg, double scale, int iter, double temp, int debug){
   VR nodes;
   double d=state.avgsize/5;
   int n=state.nw.nodes.size();
   for (int i=0;i<n;i++){
      nodes.push_back(state.nw.nodes[i].rect());
      nodes.back().extend(d);
      //debugrect(nodes.back(),0,0,255);
   }
   for (int i=0,m=state.nw.edges.size();i<m;i++){
      //if (i!=iter) continue;
      Edge &e=state.nw.edges[i];
      e.splinehandles.clear();
      e.splinepoints.clear();
      int n1=e.from;
      int n2=e.to;
      Point vec,p1,p2;
      double dir;
      switch(e.type){
         case substrate:
            dir=lim(state.nw.nodes[n1].dir+PI/2);
            vec=Point(dir);
            swap(n1,n2);
            p1=state.nw.nodes[n1];
            vec=state.nw.nodes[n2].rect().border_vec(vec);
            p2=state.nw.nodes[n2]+vec;
            break;
         case product:
            dir=lim(state.nw.nodes[n1].dir-PI/2);
            vec=Point(dir);
            vec=state.nw.nodes[n1].rect().border_vec(vec);
            p1=state.nw.nodes[n1]+vec;
            p2=state.nw.nodes[n2];
            break;
         case activator:
         case inhibitor:
         case catalyst:
            swap(n1,n2);
         default:
            p1=state.nw.nodes[n1];
            p2=state.nw.nodes[n2];
      }
      vector<Segment> vs;
      vs.push_back(Segment(ParamEdge(p1,p2),true,true));
      split_route(vs,nodes,0,n1,n2);
      Point vec1=state.nw.nodes[n1].rect().border_vec(vs.front().edge.to()-vs.front().edge.from());
      Point vec2=state.nw.nodes[n2].rect().border_vec(vs.back().edge.from()-vs.back().edge.to());
      switch(e.type){
         case activator:
         case inhibitor:
         case catalyst:
            dir=lim(state.nw.nodes[n2].dir);
            if (scalar(Point(dir),vs.back().edge.from()-vs.back().edge.to())<0) dir=lim(dir+PI);
            vec=Point(dir);
            vec=state.nw.nodes[n2].rect().border_vec(vec);
            p2=state.nw.nodes[n2]+vec;
         case substrate:
            e.splinehandles.push_back(vec1+d);
            e.splinehandles.push_back(vec+d);
            break;
         case product:
            e.splinehandles.push_back(vec+d);
            e.splinehandles.push_back(vec2+d);
            break;
         default:
            e.splinehandles.push_back(vec1+d);
            e.splinehandles.push_back(vec2+d);
      }
      for (int j=1,s=vs.size();j<s;j++){
         Point before=vs[j-1].edge.from();
         Point cur=vs[j-1].edge.to();
         //if (cur!=vs[j].edge.from()) throw "ups: edge segments not continious";
         Point after=vs[j].edge.to();
         Point dv=unit(before-cur)*d+unit(after-cur)*d;
	 debugline(cur,cur+dv,0,255,0,true);
         e.splinehandles.insert(--e.splinehandles.end(),unit(to_left(dv,PI/2))*sign(scalar(to_left(dv,PI/2),before-cur))*d);
         e.splinepoints.push_back(cur+dv);
      }
   }
}
Example #19
0
	void Lightning::create()
	{
		remove();

		Ogre::Vector3 end = mOrigin + mDirection*mLength;
		Ogre::Vector3 current, last = mOrigin;

		// Create ray segments
		for(Ogre::uint32 k = 1; k < mDivisions+1; k++)
		{
			Ogre::Vector3 current = mOrigin + mDirection*mLength*(static_cast<Ogre::Real>(k)/mDivisions);

			current += (mLength/(mDivisions*3))*Ogre::Vector3(
				Ogre::Math::RangeRandom(-1, 1), Ogre::Math::RangeRandom(-1, 1), Ogre::Math::RangeRandom(-1, 1));

			mSegments.push_back(Segment(last, current));

			mRealLength += (current-last).length();

			last = current;
		}

		// Create the associated billboard set
		mBillboardSet = mSceneManager->createBillboardSet();
		mBillboardSet->setMaterialName("SkyX_Lightning");
		mBillboardSet->setBillboardType(Ogre::BBT_ORIENTED_SELF);

		Ogre::Real width = mWidthMultiplier*3*(static_cast<Ogre::Real>(mRecursivity)/4+1)*Ogre::Math::RangeRandom(0.5f, 2.5f-mRecursivity/3);

		// Create the associated billboard for each segment
		Ogre::Real delta;
		Ogre::Vector2 bounds;
		Ogre::Billboard* bb;
		for(Ogre::uint32 k = 0; k < mSegments.size(); k++)
		{
			delta = 1.0f / mSegments.size();
			bounds = Ogre::Vector2(k*delta,(k+1)*delta);

			bounds = Ogre::Vector2(mBounds.x, mBounds.x) + bounds*(mBounds.y-mBounds.x);

			bb = mBillboardSet->createBillboard((mSegments.at(k).a+mSegments.at(k).b)/2);
			bb->setDimensions(width, (mSegments.at(k).a-mSegments.at(k).b).length());
			bb->setColour(Ogre::ColourValue(0,bounds.x,bounds.y));
			bb->mDirection = (mSegments.at(k).a-mSegments.at(k).b).normalisedCopy();

			bb = mBillboardSet->createBillboard(mSegments.at(k).a + (mSegments.at(k).a-mSegments.at(k).b).normalisedCopy()*width/2);
			bb->setDimensions(width, width);
			bb->setColour(Ogre::ColourValue(1,bounds.x,bounds.x));
			bb->mDirection = (mSegments.at(k).a-mSegments.at(k).b).normalisedCopy();
			
			bb = mBillboardSet->createBillboard(mSegments.at(k).b - (mSegments.at(k).a-mSegments.at(k).b).normalisedCopy()*width/2);
			bb->setDimensions(width, width);
			bb->setColour(Ogre::ColourValue(1,bounds.y,bounds.y));
			bb->mDirection = -(mSegments.at(k).a-mSegments.at(k).b).normalisedCopy();
		
			width *= 1-(1.0f/(mRecursivity*mRecursivity))*(1.0f/mSegments.size());
		}

		mBillboardSet->_updateBounds();

		mSceneNode->attachObject(mBillboardSet);

		mBillboardSet->setCustomParameter(0, Ogre::Vector4(1,0,0,0));

		// Ramifications
		if (mRecursivity > 0)
		{
			Ogre::Real angle;
			Ogre::Vector3 dir;
			Ogre::Real lengthMult;
			for (Ogre::uint32 k = 0; k < mDivisions-1; k++)
			{
				angle = (mSegments.at(k).b-mSegments.at(k).a).normalisedCopy().dotProduct(
					((mSegments.at(k+1).b-mSegments.at(k+1).a).normalisedCopy()));

				if (angle < Ogre::Math::RangeRandom(mAngleRange.x, mAngleRange.y))
				{
					dir = (mSegments.at(k).b-mSegments.at(k).a).normalisedCopy();
					dir.x *= Ogre::Math::RangeRandom(0.8f, 1.2f);
					dir.y *= Ogre::Math::RangeRandom(0.8f, 1.2f);
					dir.z *= Ogre::Math::RangeRandom(0.8f, 1.2f);
					dir.normalise();

					delta = 1.0f / mSegments.size();
					bounds = Ogre::Vector2(mBounds.x+(mBounds.y-mBounds.x)*(k+1)*delta,1);

					lengthMult = Ogre::Math::RangeRandom(0.1f, 0.7f);

					Lightning* lightning = new Lightning(mSceneManager, mSceneNode, mSegments.at(k).b, dir, lengthMult*mLength, 2+mDivisions*lengthMult, mRecursivity-1, mTimeMultiplier, mWidthMultiplier, bounds);
					lightning->create();
					
					mChildren.push_back(lightning);
				}
			}
		}

		mCreated = true;
	}
LimaStatusCode ParagraphBoundariesFinder::process(
  AnalysisContent& analysis) const
{
  TimeUtils::updateCurrentTime();
  SENTBOUNDLOGINIT;
  LINFO << "start finding paragraph founds";
  
  // find paragraphs in text (positions of double carriage returns),
  // then find corresponding vertices in graph

  AnalysisGraph* graph=static_cast<AnalysisGraph*>(analysis.getData(m_graph));
  if (graph==0) {
    LERROR << "no graph '" << m_graph << "' available !";
    return MISSING_DATA;
  }
  SegmentationData* boundaries=new SegmentationData(m_graph);
  analysis.setData("ParagraphBoundaries",boundaries);

  LimaStringText* text=static_cast<LimaStringText*>(analysis.getData("Text"));
  
  std::vector<uint64_t> paragraphPositions;
  int currentPos=0;
  int i=text->indexOf(m_paragraphSeparator,currentPos);
  while (i!=-1) {
    paragraphPositions.push_back((uint64_t)i);
    // goto next char that is not a carriage return
    currentPos=text->indexOf(QRegExp(QString("[^")+ m_paragraphSeparator+"]"),i+1);
    i=text->indexOf(m_paragraphSeparator,currentPos);
  }

  if (paragraphPositions.empty()) {
    LWARN << "no paragraph found";
    return SUCCESS_ID;
  }

  // find vertices related to positions in graph
  uint64_t parNum=0;
  std::deque<LinguisticGraphVertex> toVisit;
  std::set<LinguisticGraphVertex> visited;

  LinguisticGraphVertex beginParagraph=graph->firstVertex();

  toVisit.push_back(graph->firstVertex());
  visited.insert(graph->firstVertex());

  while (!toVisit.empty())
  {
    LinguisticGraphVertex currentVertex=toVisit.front();
    toVisit.pop_front();

    if (currentVertex == graph->lastVertex()) { // end of the graph
      continue;  // may be other nodes to test in queue
    }

    if (currentVertex != graph->firstVertex()) {
      Token* t = get(vertex_token,*(graph->getGraph()),currentVertex);
      uint64_t position=t->position();
      if (position >= (paragraphPositions[parNum]+1)) {
        boundaries->add(Segment("paragraph",beginParagraph,currentVertex,graph));
        beginParagraph=currentVertex;
        parNum++;
        if (parNum >= paragraphPositions.size()) {
          break;
        }
      }
    }

    // store following nodes to test
    LinguisticGraphOutEdgeIt outEdge,outEdge_end;
    boost::tie(outEdge,outEdge_end)=out_edges(currentVertex,*(graph->getGraph()));

    for (; outEdge!=outEdge_end; outEdge++) {
      LinguisticGraphVertex next=target(*outEdge,*(graph->getGraph()));
      if (visited.find(next)==visited.end()) {
        toVisit.push_back(next);
        visited.insert(next);
      }
    }
  }
  
  TimeUtils::logElapsedTime("ParagraphBoundariesFinder");
  return SUCCESS_ID;
}
/*virtual*/ void WBActionEldCheckLine::Execute()
{
	WBAction::Execute();

	STATIC_HASHED_STRING( EventOwner );
	WBEntity* const				pEntity			= GetEntity();
	WBEntity* const				pOwnerEntity	= GetOwner();
	EldritchWorld* const		pWorld			= EldritchFramework::GetInstance()->GetWorld();
	WBEventManager* const		pEventManager	= WBWorld::GetInstance()->GetEventManager();

	Vector						LineStart;
	Angles						LineOrientation;
	GetLineTransform( LineStart, LineOrientation );
	const Vector				LineDirection	= LineOrientation.ToVector();

	CollisionInfo Info;
	Info.m_CollideWorld		= true;
	Info.m_CollideEntities	= true;
	Info.m_CollidingEntity	= pOwnerEntity;
	Info.m_UserFlags		= EECF_Trace;

	if( m_LineLength > 0.0f )
	{
		const Vector			LineEnd			= LineStart + LineDirection * m_LineLength;
		const Segment			TraceSegment	= Segment( LineStart, LineEnd );
		if( !pWorld->Trace( TraceSegment, Info ) )
		{
			return;
		}
	}
	else
	{
		const Ray				TraceRay		= Ray( LineStart, LineDirection );
		if( !pWorld->Trace( TraceRay, Info ) )
		{
			return;
		}
	}

	const Vector	HitLocation		= Info.m_Intersection;
	const Vector	HitNormal		= Info.m_Plane.m_Normal;

	// Notify this entity that the line check hit that entity.
	if( Info.m_HitEntity )
	{
		WB_MAKE_EVENT( OnLineCheck, pEntity );
		WB_SET_AUTO( OnLineCheck, Hash, CheckTag, m_CheckTag );
		WB_SET_AUTO( OnLineCheck, Entity, Checked, static_cast<WBEntity*>( Info.m_HitEntity ) );
		WB_SET_AUTO( OnLineCheck, Vector, LineDirection, LineDirection );
		WB_SET_AUTO( OnLineCheck, Vector, HitLocation, HitLocation );
		WB_SET_AUTO( OnLineCheck, Vector, HitNormal, HitNormal );
		WB_DISPATCH_EVENT( pEventManager, OnLineCheck, pEntity );
	}
	else
	{
		const Vector	HalfHitNormal	= 0.5f * Info.m_Plane.m_Normal;
		const Vector	HitVoxel		= pWorld->GetVoxelCenter( HitLocation - HalfHitNormal );

		WB_MAKE_EVENT( OnLineCheckMissed, pEntity );
		WB_SET_AUTO( OnLineCheckMissed, Hash, CheckTag, m_CheckTag );
		WB_SET_AUTO( OnLineCheckMissed, Vector, LineDirection, LineDirection );
		WB_SET_AUTO( OnLineCheckMissed, Vector, HitLocation, HitLocation );
		WB_SET_AUTO( OnLineCheckMissed, Vector, HitNormal, HitNormal );
		WB_SET_AUTO( OnLineCheckMissed, Vector, HitVoxel, HitVoxel );
		WB_DISPATCH_EVENT( pEventManager, OnLineCheckMissed, pEntity );
	}
}
Example #22
0
void Light::addTriangle(Point p1, Point p2, Uint32 begin, const std::vector<Segment>& segments)
{
    if( p1 == p2 )
        return;

    for( size_t k(begin); k < segments.size(); k++ )
    {
        Segment s = convertToLocal(segments[k]);
        double a = Vector2d::angle(s.p1, s.p2);

        if( a == 0 )
            continue;

        Point p0, w1, w2;

        if( a > 0 )
        {
            w1 = s.p1;
            w2 = s.p2;
        }

        else
        {
            w1 = s.p2;
            w2 = s.p1;
        }

        if( Triangle::contains(p0, p1, p2, w1) )
        {
            Point i;
            Line::intersects(p0, w1, p1, p2, i);
            addTriangle(p1, i, k + 1, segments);
            p1 = i;
        }
            
        if( Triangle::contains(p0, p1, p2, w2) )
        {
            Point i;
            Line::intersects(p0, w2, p1, p2, i);
            addTriangle(i, p2, k + 1, segments);
            p2 = i;
        }

        Point i1, i2, i3;

        bool int1 = s.intersects(Segment(p0, p1), i1),
             int2 = s.intersects(Segment(p0, p2), i2),
             int3 = s.intersects(Segment(p1, p2), i3);

        if( (int1 && i1 == p0) || (int2 && i2 == p0) || (int3 && i3 == p0) )
            continue;

        if( int1 && int2 )
        {
            p1 = i1;
            p2 = i2;
        }

        else
        {
            if( int1 && int3 )
            {
                addTriangle(i1, i3, begin, segments);
                p1 = i3;
            }

            if( int2 && int3 )
            {
                addTriangle(i2, i3, begin, segments);
                p2 = i3;
            }
        }
    }

    m_colors.push_back({m_color.r, m_color.g, m_color.b, char(255*(m_radius - p2.length()) / m_radius)});
    m_colors.push_back({m_color.r, m_color.g, m_color.b, char(255*(m_radius - p1.length()) / m_radius)});

    addFace(getVertex(0), addVertex(p1), addVertex(p2));
}
Example #23
0
void MapWindow::DrawTask(HDC hdc, RECT rc, const POINT &Orig_Aircraft) {
    int i;
    double tmp;

    COLORREF whitecolor = RGB_WHITE;
    COLORREF origcolor = SetTextColor(hDCTemp, whitecolor);
    HPEN oldpen = 0;
    HBRUSH oldbrush = 0;

    static short size_tasklines=0;

    if (DoInit[MDI_DRAWTASK]) {
switch (ScreenSize) {
case ss480x272:
case ss272x480:
case ss320x240:
case ss240x320:
size_tasklines=NIBLSCALE(4);
break;
default:
size_tasklines=NIBLSCALE(3);
break;
}
DoInit[MDI_DRAWTASK]=false;
    }

    if (!WayPointList) return;

    oldpen = (HPEN) SelectObject(hdc, hpStartFinishThick);
    oldbrush = (HBRUSH) SelectObject(hdc, GetStockObject(HOLLOW_BRUSH));

    LockTaskData(); // protect from external task changes

    for (i = 1; ValidTaskPoint(i); i++) {
        if (!ValidTaskPoint(i + 1)) { // final waypoint
            if (ActiveWayPoint > 1 || !ValidTaskPoint(2)) {
                // only draw finish line when past the first
                // waypoint. FIXED 110307: or if task is with only 2 tps
                DrawStartEndSector(hdc, rc, Task[i].Start, Task[i].End, Task[i].Index, FinishLine, FinishRadius);
            }
        } else { // normal sector
            if (AATEnabled != TRUE) {
                //_DrawLine(hdc, PS_DASH, NIBLSCALE(3), WayPointList[Task[i].Index].Screen, Task[i].Start, RGB_PETROL, rc);
                //_DrawLine(hdc, PS_DASH, NIBLSCALE(3), WayPointList[Task[i].Index].Screen, Task[i].End, RGB_PETROL, rc);
         // DrawDashLine(hdc, size_tasklines, WayPointList[Task[i].Index].Screen, Task[i].Start, RGB_PETROL, rc);
         // DrawDashLine(hdc, size_tasklines, WayPointList[Task[i].Index].Screen, Task[i].End, RGB_PETROL, rc);
            }

            int Type = 0;
            double Radius = 0.;
            GetTaskSectorParameter(i, &Type, &Radius);
            switch (Type) {
                case CIRCLE:
                    tmp = Radius * zoom.ResScaleOverDistanceModify();
                    Circle(hdc,
                            WayPointList[Task[i].Index].Screen.x,
                            WayPointList[Task[i].Index].Screen.y,
                            (int) tmp, rc, false, false);
                    break;
                case SECTOR:
                    tmp = Radius * zoom.ResScaleOverDistanceModify();
                    Segment(hdc,
                            WayPointList[Task[i].Index].Screen.x,
                            WayPointList[Task[i].Index].Screen.y, (int) tmp, rc,
                            Task[i].AATStartRadial - DisplayAngle,
                            Task[i].AATFinishRadial - DisplayAngle);
                    break;
                case DAe:
                    if (!AATEnabled) { // this Type exist only if not AAT task
                        // JMW added german rules
                        tmp = 500 * zoom.ResScaleOverDistanceModify();
                        Circle(hdc,
                                WayPointList[Task[i].Index].Screen.x,
                                WayPointList[Task[i].Index].Screen.y,
                                (int) tmp, rc, false, false);

                        tmp = 10e3 * zoom.ResScaleOverDistanceModify();

                        Segment(hdc,
                                WayPointList[Task[i].Index].Screen.x,
                                WayPointList[Task[i].Index].Screen.y, (int) tmp, rc,
                                Task[i].AATStartRadial - DisplayAngle,
                                Task[i].AATFinishRadial - DisplayAngle);
                    }
                    break;
                case LINE:
                    if (!AATEnabled) { // this Type exist only if not AAT task
                    	if(ISGAAIRCRAFT) {
                    		POINT start,end;
                    		double rotation=AngleLimit360(Task[i].Bisector-DisplayAngle);
                    		int length=14*ScreenScale; //Make intermediate WP lines always of the same size independent by zoom level
                    		start.x=WayPointList[Task[i].Index].Screen.x+(long)(length*fastsine(rotation));
                    		start.y=WayPointList[Task[i].Index].Screen.y-(long)(length*fastcosine(rotation));
                    		rotation=Reciprocal(rotation);
                    		end.x=WayPointList[Task[i].Index].Screen.x+(long)(length*fastsine(rotation));
                    		end.y=WayPointList[Task[i].Index].Screen.y-(long)(length*fastcosine(rotation));
                    		_DrawLine(hdc, PS_SOLID, NIBLSCALE(3), start, end, taskcolor, rc);
                    	} else _DrawLine(hdc, PS_SOLID, NIBLSCALE(3), Task[i].Start, Task[i].End, taskcolor, rc);
                    }
                    break;
                case CONE:
                    tmp = Radius * zoom.ResScaleOverDistanceModify();
                    int center_x = WayPointList[Task[i].Index].Screen.x;
                    int center_y = WayPointList[Task[i].Index].Screen.y;
                    Circle(hdc, center_x, center_y, (int) tmp, rc, false, false);
                    HPEN prevPen = (HPEN)::SelectObject(hdc, hpTerrainLine);
                    for( int j = 1; j < 5 && tmp > 0; ++j) {
                        Circle(hdc, center_x, center_y, tmp -= NIBLSCALE(5), rc, true, true);
                    }
                    ::SelectObject(hdc, prevPen);
                    break;
            }

            if (AATEnabled && !DoOptimizeRoute()) {
                // ELSE HERE IS *** AAT ***
                // JMW added iso lines
                if ((i == ActiveWayPoint) || (mode.Is(Mode::MODE_TARGET_PAN) && (i == TargetPanIndex))) {
                    // JMW 20080616 flash arc line if very close to target
                    static bool flip = false;

                    if (DerivedDrawInfo.WaypointDistance < AATCloseDistance()*2.0) {
                        flip = !flip;
                    } else {
                        flip = true;
                    }
                    if (flip) {
                        for (int j = 0; j < MAXISOLINES - 1; j++) {
                            if (TaskStats[i].IsoLine_valid[j]
                                    && TaskStats[i].IsoLine_valid[j + 1]) {
                                _DrawLine(hdc, PS_SOLID, NIBLSCALE(2),
                                        TaskStats[i].IsoLine_Screen[j],
                                        TaskStats[i].IsoLine_Screen[j + 1],
                                        RGB(0, 0, 255), rc);
                            }
                        }
                    }
                }
            }
        }
    }

    if ((ActiveWayPoint < 2) && ValidTaskPoint(0) && ValidTaskPoint(1)) {
        DrawStartEndSector(hdc, rc, Task[0].Start, Task[0].End, Task[0].Index, StartLine, StartRadius);
        if (EnableMultipleStartPoints) {
            for (i = 0; i < MAXSTARTPOINTS; i++) {
                if (StartPoints[i].Active && ValidWayPoint(StartPoints[i].Index)) {
                    DrawStartEndSector(hdc, rc, StartPoints[i].Start, StartPoints[i].End,
                            StartPoints[i].Index, StartLine, StartRadius);
                }
            }
        }
    }
    
    for (i = 0; ValidTaskPoint(i + 1); i++) {
        int imin = min(Task[i].Index, Task[i + 1].Index);
        int imax = max(Task[i].Index, Task[i + 1].Index);
        // JMW AAT!
        double bearing = Task[i].OutBound;
        POINT sct1, sct2;
        if (AATEnabled) {
            LatLon2Screen(Task[i].AATTargetLon,
                    Task[i].AATTargetLat,
                    sct1);
            LatLon2Screen(Task[i + 1].AATTargetLon,
                    Task[i + 1].AATTargetLat,
                    sct2);
            DistanceBearing(Task[i].AATTargetLat,
                    Task[i].AATTargetLon,
                    Task[i + 1].AATTargetLat,
                    Task[i + 1].AATTargetLon,
                    NULL, &bearing);

            // draw nominal track line
            DrawDashLine(hdc, NIBLSCALE(1), // 091217
                    WayPointList[imin].Screen,
                    WayPointList[imax].Screen,
                    taskcolor, rc);
        } else {
            sct1 = WayPointList[imin].Screen;
            sct2 = WayPointList[imax].Screen;
        }

        if ((i >= ActiveWayPoint && DoOptimizeRoute()) || !DoOptimizeRoute()) {
            POINT ClipPt1 = sct1, ClipPt2 = sct2;
            if(LKGeom::ClipLine((POINT) {rc.left, rc.top}, (POINT) {rc.right, rc.bottom}, ClipPt1, ClipPt2)) {
                DrawMulticolorDashLine(hdc, size_tasklines,
                        sct1,
                        sct2,
                        taskcolor, RGB_BLACK,rc);
                
                // draw small arrow along task direction
                POINT p_p;
                POINT Arrow[2] = {
                    {6, 6},
                    {-6, 6}
                };
                ScreenClosestPoint(sct1, sct2,
                        Orig_Aircraft, &p_p, NIBLSCALE(25));
                threadsafePolygonRotateShift(Arrow, 2, p_p.x, p_p.y, bearing - DisplayAngle);

                _DrawLine(hdc, PS_SOLID, size_tasklines-NIBLSCALE(1), Arrow[0], p_p, taskcolor, rc);
                _DrawLine(hdc, PS_SOLID, size_tasklines-NIBLSCALE(1), Arrow[1], p_p, taskcolor, rc);
            }
        }
    }
    
    // Draw DashLine From current position to Active TurnPoint center
    if(ValidTaskPoint(ActiveWayPoint)) {
        POINT ptStart;
        LatLon2Screen(DrawInfo.Longitude, DrawInfo.Latitude, ptStart);
        DrawDashLine(hdc, NIBLSCALE(1),
                    ptStart,
                    WayPointList[Task[ActiveWayPoint].Index].Screen,
                    taskcolor, rc);

    }

    {
        UnlockTaskData();
    }

    // restore original color
    SetTextColor(hDCTemp, origcolor);
    SelectObject(hdc, oldpen);
    SelectObject(hdc, oldbrush);
}
int CObject::Create (ubyte nType, ubyte nId, short nCreator, short nSegment,
							const CFixVector& vPos, const CFixMatrix& mOrient,
							fix xSize, ubyte cType, ubyte mType, ubyte rType)
{
#if DBG
if (nType == OBJ_WEAPON) {
	nType = nType;
	if ((nCreator >= 0) && (OBJECTS [nCreator].info.nType == OBJ_ROBOT))
		nType = nType;
	if (nId == FLARE_ID)
		nType = nType;
	if (gameData.objs.bIsMissile [(int) nId])
		nType = nType;
	}
else if (nType == OBJ_ROBOT) {
#if 0
	if (ROBOTINFO ((int) nId).bossFlag && (BOSS_COUNT >= MAX_BOSS_COUNT))
		return -1;
#endif
	}
else if (nType == OBJ_HOSTAGE)
	nType = nType;
else if (nType == OBJ_FIREBALL)
	nType = nType;
else if (nType == OBJ_REACTOR)
	nType = nType;
else if (nType == OBJ_DEBRIS)
	nType = nType;
else if (nType == OBJ_MARKER)
	nType = nType;
else if (nType == OBJ_PLAYER)
	nType = nType;
else if (nType == OBJ_POWERUP)
	nType = nType;
#endif

SetSegment (FindSegByPos (vPos, nSegment, 1, 0));
if ((Segment () < 0) || (Segment () > gameData.segs.nLastSegment))
	return -1;

if (nType == OBJ_DEBRIS) {
	if (gameData.objs.nDebris >= gameStates.render.detail.nMaxDebrisObjects)
		return -1;
	}

// Zero out object structure to keep weird bugs from happening in uninitialized fields.
m_nId = OBJ_IDX (this);
SetSignature (gameData.objs.nNextSignature++);
SetType (nType);
SetId (nId);
SetLastPos (vPos);
SetPos (&vPos);
SetSize (xSize);
SetCreator ((sbyte) nCreator);
SetOrient (&mOrient);
SetControlType (cType);
SetMovementType (mType);
SetRenderType (rType);
SetContainsType (-1);
SetLifeLeft (
	((gameData.app.nGameMode & GM_ENTROPY) && (nType == OBJ_POWERUP) && (nId == POW_HOARD_ORB) && (extraGameInfo [1].entropy.nVirusLifespan > 0)) ?
	I2X (extraGameInfo [1].entropy.nVirusLifespan) : IMMORTAL_TIME);
SetAttachedObj (-1);
m_xCreationTime = gameData.time.xGame;
#if 0
if (GetControlType () == CT_POWERUP)
	CPowerupInfo::SetCount (1);
// Init physics info for this CObject
if (GetMovementType () == MT_PHYSICS)
	m_vStartVel.SetZero ();
if (GetRenderType () == RT_POLYOBJ)
	CPolyObjInfo::SetTexOverride (-1);

if (GetType () == OBJ_WEAPON) {
	CPhysicsInfo::SetFlags (CPhysInfo.GetFlags () | WI_persistent (m_info.nId) * PF_PERSISTENT);
	CLaserInfo::SetCreationTime (gameData.time.xGame);
	CLaserInfo::SetLastHitObj (0);
	CLaserInfo::SetScale (I2X (1));
	}
else if (GetType () == OBJ_DEBRIS)
	gameData.objs.nDebris++;
if (GetControlType () == CT_POWERUP)
	CPowerupInfo::SetCreationTime (gameData.time.xGame);
else if (GetControlType () == CT_EXPLOSION) {
	CAttachedInfo::SetPrev (-1);
	CAttachedInfo::SetNext (-1);
	CAttachedInfo::SetParent (-1);
	}
#endif
Link ();
LinkToSeg (nSegment);
return m_nId;
}
Example #25
0
int main(void) {

  consoleDemoInit();

  //videoSetMode(MODE_FB0);
  videoSetMode( MODE_5_2D );
  vramSetBankA(VRAM_A_MAIN_BG);
  vramSetBankB(VRAM_B_MAIN_BG);
  // vramSetBankC(VRAM_C_MAIN_BG);
  // vramSetBankD(VRAM_D_MAIN_BG_0x06040000);
  int bg = bgInit(3, BgType_Bmp8, BgSize_B8_512x512, 0,0);  //vramSetBankA(VRAM_A_LCD);

  lcdMainOnBottom();
  // lcdMainOnTop();

  printf("Video modes configured\n");
  printf("BG ID %d\n", bg);

  if (fatInitDefault())
    printf("FAT initialized\n");
  else
    printf("FAT initialization failed\n");

  AppState state;
  uiOpenNotebook(state);

  // Keyboard *kbd =  keyboardDemoInit();

  Segment * currentSegment = NULL;


  touchPosition touch;

  while (1) {
    scanKeys();
    
    if(keysHeld() & KEY_TOUCH)
      {
	// write the touchscreen coordinates in the touch variable
	touchRead(&touch);
	
	Point screenPoint = Point(touch.px, touch.py);
	Point imagePoint = state.convertScreenToImage(screenPoint);

	if (currentSegment == NULL) {
	  state.currentPage->segments.push_back(Segment());
	  currentSegment = &(state.currentPage->segments[state.currentPage->segments.size()-1]);
	  currentSegment->points.push_back(imagePoint);
	  continue;
	}

	Point lastImagePoint = currentSegment->points[currentSegment->points.size()-1];
	currentSegment->points.push_back(imagePoint);

	Point bufferPoint = state.convertScreenToBuffer(screenPoint);
	Point lastBufferPoint = state.convertImageToBuffer(lastImagePoint);
	drawLine(lastBufferPoint.x, lastBufferPoint.y,  bufferPoint.x, bufferPoint.y, RGB15(31,0,0) | BIT(15));
      }    
    else {
      currentSegment = NULL;
    }
    if (keysDown() & KEY_X) {
      int page = state.lastPage+1;
      while (state.notebook.pages.size() < page+1) {
	state.notebook.pages.push_back(Page());
	printf("New Page created\n");
      }
      state.currentPage = &(state.notebook.pages[page]);
      currentSegment = NULL;

      printf("Display page %d\n", page);

      fillDisplay(RGB15(0,0,0) | BIT(15), page, state);
      drawPage(state.currentPage, RGB15(31,0,0) | BIT(15), state);
    }
    if (keysDown() & KEY_Y) {
      int page = 0;
      if (state.lastPage > 0) {
	page = state.lastPage-1;
      }
      state.currentPage = &(state.notebook.pages[page]);
      currentSegment = NULL;

      printf("Display page %d\n", page);

      fillDisplay(RGB15(0,0,0) | BIT(15), page, state);
      drawPage(state.currentPage, RGB15(31,0,0) | BIT(15), state);
    }
    if (keysDown() & KEY_A) {
      int page = 0;
      std::string fileName = state.notebookName + "/notes.txt";
      state.notebook = loadFile(fileName.c_str());

      state.currentPage = &(state.notebook.pages[page]);
      currentSegment = NULL;

      printf("Display page %d\n", page);

      fillDisplay(RGB15(0,0,0) | BIT(15), page, state);
      drawPage(state.currentPage, RGB15(31,0,0) | BIT(15), state);
    }
    if (keysDown() & KEY_B) {
      std::string fileName = state.notebookName + "/notes.txt";
      saveFile(fileName.c_str(), state.notebook);
    }
    if (keysDown() & KEY_LEFT) {
      state.scroll_x-=50;
      updateCenter(state);
    }
    if (keysDown() & KEY_RIGHT) {
      state.scroll_x+=50;
      updateCenter(state);
    }
    if (keysDown() & KEY_UP) {
      state.scroll_y-=50;
      updateCenter(state);
    }
    if (keysDown() & KEY_DOWN) {
      state.scroll_y+=50;
      updateCenter(state);
    }
    if (keysDown() & KEY_START) {
      uiOpenNotebook(state);
    }

    swiWaitForVBlank();
  }
}
Example #26
0
Download::Download(UserConnection& conn, QueueItem& qi) noexcept : Transfer(conn, qi.getTarget(), qi.getTTH()),
	tempTarget(qi.getTempTarget())
{
	conn.setDownload(this);
	
	QueueItem::SourceConstIter source = qi.getSource(getUser());

	if(qi.isSet(QueueItem::FLAG_PARTIAL_LIST)) {
		setType(TYPE_PARTIAL_LIST);
	} else if(qi.isSet(QueueItem::FLAG_USER_LIST)) {
		setType(TYPE_FULL_LIST);
	}

	if(source->isSet(QueueItem::Source::FLAG_PARTIAL))
		setFlag(FLAG_PARTIAL);
	if(qi.isSet(QueueItem::FLAG_CLIENT_VIEW))
		setFlag(FLAG_VIEW);
	if(qi.isSet(QueueItem::FLAG_MATCH_QUEUE))
		setFlag(FLAG_QUEUE);
	if(qi.isSet(QueueItem::FLAG_VIEW_NFO))
		setFlag(FLAG_NFO);
	if(qi.isSet(QueueItem::FLAG_RECURSIVE_LIST))
		setFlag(FLAG_RECURSIVE);
	if(qi.isSet(QueueItem::FLAG_TTHLIST_BUNDLE))
		setFlag(FLAG_TTHLIST_BUNDLE);
	if (qi.getPriority() == QueueItemBase::HIGHEST)
		setFlag(FLAG_HIGHEST_PRIO);

	if (qi.getBundle()) {
		dcassert(!qi.isSet(QueueItem::FLAG_USER_LIST));
		dcassert(!qi.isSet(QueueItem::FLAG_TEXT));
		setBundle(qi.getBundle());
	}
	
	if(getType() == TYPE_FILE && qi.getSize() != -1) {
		if(HashManager::getInstance()->getTree(getTTH(), getTigerTree())) {
			setTreeValid(true);
			setSegment(qi.getNextSegment(getTigerTree().getBlockSize(), conn.getChunkSize(), conn.getSpeed(), source->getPartialSource(), true));
			qi.setBlockSize(getTigerTree().getBlockSize());
		} else if(conn.isSet(UserConnection::FLAG_SUPPORTS_TTHL) && !source->isSet(QueueItem::Source::FLAG_NO_TREE) && qi.getSize() > HashManager::MIN_BLOCK_SIZE) {
			// Get the tree unless the file is small (for small files, we'd probably only get the root anyway)
			setType(TYPE_TREE);
			getTigerTree().setFileSize(qi.getSize());
			setSegment(Segment(0, -1));
		} else {
			// Use the root as tree to get some sort of validation at least...
			getTigerTree() = TigerTree(qi.getSize(), qi.getSize(), getTTH());
			setTreeValid(true);
			setSegment(qi.getNextSegment(getTigerTree().getBlockSize(), 0, 0, source->getPartialSource(), true));
		}
		
		if ((getStartPos() + getSegmentSize()) != qi.getSize() || (conn.getDownload() && conn.getDownload()->isSet(FLAG_CHUNKED))) {
			setFlag(FLAG_CHUNKED);
		}

		if(getSegment().getOverlapped()) {
			setFlag(FLAG_OVERLAP);

			// set overlapped flag to original segment
			for(auto d: qi.getDownloads()) {
				if(d->getSegment().contains(getSegment())) {
					d->setOverlapped(true);
					break;
				}
			}
		}
	}
}
Example #27
0
Segment Scene::random_segment(const CGAL::Bbox_3& bbox)
{
    Point p = random_point(bbox);
    Point q = random_point(bbox);
    return Segment(p,q);
}
Example #28
0
Segment QueueItem::getNextSegment(int64_t blockSize, int64_t wantedSize) const {
	if(getSize() == -1 || blockSize == 0) {
		return Segment(0, -1);
	}
	
	if(!BOOLSETTING(SEGMENTED_DL) && !downloads.empty()) {
		return Segment(0, 0);
	}
	
	int64_t remaining = getSize() - getDownloadedBytes();
	
	int64_t targetSize;
	if(BOOLSETTING(SEGMENTED_DL)) {
		double done = static_cast<double>(getDownloadedBytes()) / getSize();
		
		// We want smaller blocks at the end of the transfer, squaring gives a nice curve...
		targetSize = wantedSize * std::max(0.25, (1. - (done * done)));
		
		if(targetSize > blockSize) {
			// Round off to nearest block size
			targetSize = ((targetSize + (blockSize / 2)) / blockSize) * blockSize;
		} else {
			targetSize = blockSize;
		}
	} else {
		targetSize = remaining;
	}
	
	int64_t start = 0;
	int64_t curSize = targetSize;
	
	while(start < getSize()) {
		int64_t end = std::min(getSize(), start + curSize);
		Segment block(start, end - start);
		bool overlaps = false;
		for(SegmentIter i = done.begin(); !overlaps && i != done.end(); ++i) {
			if(curSize <= blockSize) {
				int64_t dstart = i->getStart();
				int64_t dend = i->getEnd();
				// We accept partial overlaps, only consider the block done if it is fully consumed by the done block
				if(dstart <= start && dend >= end) {
					overlaps = true;
				}
			} else {
				overlaps = block.overlaps(*i);
			}
		}
		
		for(DownloadList::const_iterator i = downloads.begin(); !overlaps && i !=downloads.end(); ++i) {
			overlaps = block.overlaps((*i)->getSegment());
		}
		
		if(!overlaps) {
			return block;
		}
		
		if(curSize > blockSize) {
			curSize -= blockSize;
		} else {
			start = end;
			curSize = targetSize;
		}
	}
	
	return Segment(0, 0);
}
Example #29
0
MachOLayout<A>::MachOLayout(const void* machHeader, uint64_t offset, const char* path, ino_t inode, time_t modTime, uid_t uid)
 : fPath(path), fOffset(offset), fArchPair(0,0), fMTime(modTime), fInode(inode), fHasSplitSegInfo(false), fRootOwned(uid==0),
   fShareableLocation(false), fDynamicLookupLinkage(false), fMainExecutableLookupLinkage(false), fIsDylib(false), 
	fHasDyldInfo(false), fDyldInfoExports(NULL)
{
	fDylibID.name = NULL;
	fDylibID.currentVersion = 0;
	fDylibID.compatibilityVersion = 0;
	bzero(fUUID, sizeof(fUUID));
	
	const macho_header<P>* mh = (const macho_header<P>*)machHeader;
	if ( mh->cputype() != arch() )
		throw "Layout object is wrong architecture";
	switch ( mh->filetype() ) {
		case MH_DYLIB:
			fIsDylib = true;
			break;
		case MH_BUNDLE:
		case MH_EXECUTE:
		case MH_DYLIB_STUB:
		case MH_DYLINKER:
			break;
		default:
			throw "file is not a mach-o final linked image";
	}
	fFlags = mh->flags();
	fFileType = mh->filetype();
	fArchPair.arch = mh->cputype();
	fArchPair.subtype = mh->cpusubtype();
	
	const macho_dyld_info_command<P>* dyldInfo = NULL;
	const macho_symtab_command<P>* symbolTableCmd = NULL;
	const macho_dysymtab_command<P>* dynamicSymbolTableCmd = NULL;
	const macho_load_command<P>* const cmds = (macho_load_command<P>*)((uint8_t*)mh + sizeof(macho_header<P>));
	const uint32_t cmd_count = mh->ncmds();
	const macho_load_command<P>* cmd = cmds;
	for (uint32_t i = 0; i < cmd_count; ++i) {
		switch ( cmd->cmd() ) {
			case LC_ID_DYLIB:	
				{
					macho_dylib_command<P>* dylib  = (macho_dylib_command<P>*)cmd;
					fDylibID.name = strdup(dylib->name());
					fDylibID.currentVersion = dylib->current_version();
					fDylibID.compatibilityVersion = dylib->compatibility_version();
					fNameFileOffset = dylib->name() - (char*)machHeader;
					fShareableLocation = ( (strncmp(fDylibID.name, "/usr/lib/", 9) == 0) || (strncmp(fDylibID.name, "/System/Library/", 16) == 0) );
				}
				break;
			case LC_LOAD_DYLIB:
			case LC_LOAD_WEAK_DYLIB:
			case LC_REEXPORT_DYLIB:
			case LC_LOAD_UPWARD_DYLIB:
				{
					macho_dylib_command<P>* dylib = (macho_dylib_command<P>*)cmd;
					Library lib;
					lib.name = strdup(dylib->name());
					lib.currentVersion = dylib->current_version();
					lib.compatibilityVersion = dylib->compatibility_version();
					lib.weakImport = ( cmd->cmd() == LC_LOAD_WEAK_DYLIB );
					fLibraries.push_back(lib);
				}
				break;
			case LC_SEGMENT_SPLIT_INFO:
				fHasSplitSegInfo = true;
				break;
			case macho_segment_command<P>::CMD:
				{
					macho_segment_command<P>* segCmd = (macho_segment_command<P>*)cmd;
					fSegments.push_back(Segment(segCmd->vmaddr(), segCmd->vmsize(), segCmd->fileoff(), 
								segCmd->filesize(), segCmd->initprot(), segCmd->segname()));
				}
				break;
			case LC_SYMTAB:
				symbolTableCmd = (macho_symtab_command<P>*)cmd;
				break;
			case LC_DYSYMTAB:
				dynamicSymbolTableCmd = (macho_dysymtab_command<P>*)cmd;
				break;
			case LC_DYLD_INFO:
			case LC_DYLD_INFO_ONLY:
				fHasDyldInfo = true;
				dyldInfo = (struct macho_dyld_info_command<P>*)cmd;
				break;
			case LC_UUID:
				{
					const macho_uuid_command<P>* uc = (macho_uuid_command<P>*)cmd;
					memcpy(&fUUID, uc->uuid(), 16);
				}
				break;
		}
		cmd = (const macho_load_command<P>*)(((uint8_t*)cmd)+cmd->cmdsize());
	}

	fLowSegment = NULL;
	fLowExecutableSegment = NULL;
	fLowWritableSegment = NULL;
	fLowReadOnlySegment = NULL;
	fVMExecutableSize = 0;
	fVMWritablSize = 0;
	fVMReadOnlySize = 0;
	fVMSize = 0;
	const Segment* highSegment = NULL;
	for(std::vector<Segment>::const_iterator it = fSegments.begin(); it != fSegments.end(); ++it) {
		const Segment& seg = *it;
		if ( (fLowSegment == NULL) || (seg.address() < fLowSegment->address()) )
			fLowSegment = &seg;
		if ( (highSegment == NULL) || (seg.address() > highSegment->address()) )
			highSegment = &seg;
		if ( seg.executable() ) {
			if ( (fLowExecutableSegment == NULL) || (seg.address() < fLowExecutableSegment->address()) )
				fLowExecutableSegment = &seg;
			fVMExecutableSize += seg.size();
		}
		else if ( seg.writable()) {
			if ( (fLowWritableSegment == NULL) || (seg.address() < fLowWritableSegment->address()) )
				fLowWritableSegment = &seg;
			fVMWritablSize += seg.size();
		}
		else {
			if ( (fLowReadOnlySegment == NULL) || (seg.address() < fLowReadOnlySegment->address()) )
				fLowReadOnlySegment = &seg;
			fVMReadOnlySize += seg.size();
		}		
	}
	if ( (highSegment != NULL) && (fLowSegment != NULL) )
		fVMSize = (highSegment->address() + highSegment->size() - fLowSegment->address() + 4095) & (-4096);			
	
	// scan undefines looking, for magic ordinals
	if ( (symbolTableCmd != NULL) && (dynamicSymbolTableCmd != NULL) ) {
		const macho_nlist<P>* symbolTable = (macho_nlist<P>*)((uint8_t*)machHeader + symbolTableCmd->symoff());
		const uint32_t startUndefs = dynamicSymbolTableCmd->iundefsym();
		const uint32_t endUndefs = startUndefs + dynamicSymbolTableCmd->nundefsym();
		for (uint32_t i=startUndefs; i < endUndefs; ++i) {
			uint8_t ordinal = GET_LIBRARY_ORDINAL(symbolTable[i].n_desc());
			if ( ordinal == DYNAMIC_LOOKUP_ORDINAL )
				fDynamicLookupLinkage = true;
			else if ( ordinal == EXECUTABLE_ORDINAL )
				fMainExecutableLookupLinkage = true;
		}
	}
	
	if ( dyldInfo != NULL ) {
		if ( dyldInfo->export_off() != 0 ) {
			fDyldInfoExports = (uint8_t*)machHeader + dyldInfo->export_off();
		}
	}

}
Example #30
0
TEST(Segment, Intersection_Segment_oy){ // ||oy
    vector<Point> ans = { Point(3,3) };
    vector<Point> res = Segment(2,4,4,2).intersection(Segment(3,1,3,5));
    ASSERT_EQ(ans, res);
};