Пример #1
0
/** Get edge to the left of given edge */
GEdge *
NodeNav::edgeInDir( GEdge * edge, NavDirection dir) const
{
    /* Applicable only for top and bottom sectors */
    if ( !isDirApplicable( dir, sector()))
    {
        return NULL;
    }
    
    GNode *n = otherEnd( edge);
    /* item corresponding to other (than node_priv) node */
    if ( isNullP( n))
        return NULL;

    NodeItem *item = n->item();
    
    // in current node's coordinates
    QPointF edge_point = node()->item()->mapFromItem( item, item->boundingRect().center());

    GEdge *res = NULL;
    qreal min_delta = 0;
    /** For each edge */   
    for ( Node::EdgeIter e_iter = node()->edgesBegin(),
                         e_end = node()->edgesEnd();
          e_iter != e_end;
          e_iter++ )
    {
        GEdge *e = static_cast<GEdge *>( e_iter.edge());
        if ( isEdgeInSector( e) && areNotEqP( e, edge))
        {
            NodeItem *p_item = static_cast<GNode *>( e_iter.node())->item();
            QPointF point = node()->item()->mapFromItem( p_item, p_item->boundingRect().center());
            if ( isPointInDir( point, edge_point, dir))
            {
                qreal delta = deltaInDir( point, edge_point, dir);
                if ( isNullP( res) 
                     || delta < min_delta) // for selection of closest edge
                {
                    res = e;
                    min_delta = delta;
                }
            }
        }
    }

    return res;
}
Пример #2
0
/** Destructor */
GGraph::~GGraph()
{
    freeMarker( nodeTextIsShown);
    for ( GNode *node = firstNode();
          isNotNullP( node);
          )
    {
        GNode* next = node->nextNode();
        int ir_id = node->irId();
        deleteNode( node);
        node = next;
    }
    foreach ( GStyle *style, styles)
    {
        delete style;
    }
}
Пример #3
0
/* Set a new value for the romanized name
 * string value in the GNode data tree, and
 * create a node in the tree if needed.
 */
void GIndiEntry::setRomanizedName(const QString & romanName) {
    // Append a new node to the tree if needed
    if (!_romanNode) {
        // Create the new node
        _romanNode = new GNode("2 ROMN " + romanName);
        // Append it to the end of _nameNode's children
        GNode * n = _nameNode->firstChild();
        if (!n) { // No existing first child
            _nameNode->setFirstChild(_romanNode);
        }
        else { // Pre-existing sub-list
            // Go to the end of the sub-list
            while (n->next()) n = n->next();
            // Append the new node there
            n->setNext(_romanNode);
        }
    }
    // Alter the existing node if needed
    else {
        _romanNode->setData(romanName);
    }
}
Пример #4
0
bool GPath::FindPath(int sx, int sy, int destx, int desty) {
  Path.clear();
  App->Log << "Pathfinding session started" << std::endl;
  App->Log << "sx : " << sx << std::endl;
  App->Log << "sy : " << sy << std::endl;
  App->Log << "destx : " << destx << std::endl;
  App->Log << "desty : " << desty << std::endl;
  DestX = destx; 
  DestY = desty;
  GetAreaBounds();

  if (destx == sx && desty == sy) //path found
    return true;  

  for(int y = 0; y < MaxY; y++) {
    for(int x = 0; x < MaxX; x++) {
      Nodes.push_back(NULL);      
    }
  }

  //App->Log << "Empty nodes ready\n";
      
  GNode* start = new GNode(sx, sy);  
  GNode* end = NULL;
  int type = GetTileType(sx, sy);
  start->SetType(type);
  start->CalcPoints();
  SetNode(start);
  Open.push(start);

  // App->Log << "start->GetX(): " << start->GetX() << std::endl;
  // App->Log << "start->GetY(): " << start->GetY() << std::endl;
  // App->Log << "Open.top(): " << Open.top() << std::endl;
  // App->Log << "Nodes.size(): " << Nodes.size() << std::endl;
  // App->Log << "Open.empty(): " << Open.empty() << std::endl;

  bool found = false;
 
  while (!Open.empty()) {
    //take the node with lowest F value
    GNode* node = Open.top();   
    
    //remove from open list
    node->Close();
    Open.pop();

    
    
    App->Log << "||||Chosen one X: " << node->GetX() << " Y: " << node->GetY() << std::endl;
    App->Log << "--------------------\n";
   
    
    if (node->GetX() == DestX &&
	node->GetY() == DestY) {
      // App->Log << "found\n";
      found = true;
      end = node;
      // break; doesn't work here, damn it!
      while (!Open.empty()) Open.pop();
    }
    
    if (!found)
      FindAdjacent(node);
  }
  
  if (found) {
    GNode* node = end;
    GPoint point;
    point.x = node->GetX();
    point.y = node->GetY();
    // App->Log << "point.x: " << point.x << std::endl;
    // App->Log << "point.y: " << point.y << std::endl;
    Path.push_back(point);
    while (true) {
      GPoint point;
      GNode* parent = node->GetParent();

      if (NULL == parent) {
	
	break;
      }

      if (*parent == *start)
	break;

      point.x = parent->GetX();
      point.y = parent->GetY();
      // App->Log << "point.x: " << point.x << std::endl;
      // App->Log << "point.y: " << point.y << std::endl;
      Path.push_back(point);
     
      //App->Log << "Parent: " << parent << std::endl;   
      node = node->GetParent();   
      //App->Log << "new node: " << node << std::endl;   
      
    }   
    // App->Log << "X:\n"; 
    // std::vector<GPoint>::iterator it = Path.begin();
    // while (it != Path.end()) {
    //   App->Log << "X: " << it->x << std::endl;
    //   App->Log << "Y: " << it->y << std::endl;
    //   it++;
    // }
    App->Log << "done\n";
    
  }
  
  Cleanup();
  
  return found;
}
Пример #5
0
void
TestParser::parseLine( QString line)
{
    QString n_str("Node ");
    QString e_str("Edge ");
    /** Node recognition */
    QRegExp node_rx("CF ?(Enter)? ?(\\w*) Node (\\d+)");
    
    /** Edge recognition */
    QRegExp edge_rx("CF EDGE (\\d+) \\[(\\d+)->(\\d+)\\]");
    QTextStream stream( stdout);
            
    /** Expression recognition */
    int pos = 0;

    if (  edge_rx.indexIn( line) != -1)
    {
        QString name = e_str.append( edge_rx.cap(1));
        QString pred_name("Node ");
        pred_name.append( edge_rx.cap( 2));
        QString succ_name("Node ");
        succ_name.append( edge_rx.cap( 3));
        
        /** Back edge */
        QRegExp back_rx("Back");
           
        /** Add edge to symtab */
        if ( symtab.find( name) == symtab.end() 
             && symtab.find( pred_name) != symtab.end() 
             && symtab.find( succ_name) != symtab.end())
        {
            SymEdge *edge = new SymEdge( name);
            edge->setPred( pred_name);
            edge->setSucc( succ_name);
            symtab[ name] = edge;

            /** Add edge to graph */
            GNode* pred = static_cast< SymNode *>( symtab[ pred_name])->node();
            GNode* succ = static_cast< SymNode *>( symtab[ succ_name])->node();
            GEdge* e = graph->graph()->newEdge( pred, succ);
#ifdef _DEBUG            
            //stream << name << ": " << pred_name << "->" << succ_name << endl;
#endif      
            if (  back_rx.indexIn( line) != -1 && !e->isSelf())
            {
                GNode* label = e->insertLabelNode( QPointF( 0,0));                
                label->item()->setPlainText( "Back");
            }
        }
    } else if ( node_rx.indexIn( line) != -1 )
    {
		bool good_id = false;
		int ir_id = node_rx.cap(3).toInt( &good_id);
		QString text = QString("Node ").append( node_rx.cap(3));
        QString name = n_str.append( node_rx.cap(3));
        if ( !node_rx.cap( 1).isEmpty())
        {
            text.append("\n").append( node_rx.cap(1));
        }
        if ( !node_rx.cap( 2).isEmpty())
        {
            text.append("\n").append( node_rx.cap(2));
        }
        /** Add node to symtab */
        if ( symtab.find( name ) == symtab.end())
        {
            SymNode* node = new SymNode( name);
            curr_node = static_cast<CFNode *>( graph->graph()->newNode());
            curr_node->setDoc( new QTextDocument());
            node->setNode( curr_node);
            node->node()->item()->setPlainText( text);
		    if ( good_id)
		    {
			    node->node()->setIRId( ir_id);
		    }
            symtab[ name] = node;
#ifdef _DEBUG
            //stream << name << endl;
#endif
        }
    } else
    {
        if ( !isStateNode())
            setStateDefault();
    }
    if ( isStateNode())
    {
        node_text.append( line).append( "\n");
    }
}
/// ==================================================================================
/// search(std::vector<std::vector<GNode> >& paths, GNode st)
/// Theta* search
/// ==================================================================================
int Grid_planner::thetastar_search(std::vector<std::vector<GNode> >& paths, GNode st){



    // prep start and goal nodes
    Tpoint gc = getEnclosingCell(goal_.x, goal_.y);

    // GNode gl(gc.x*cellwidth_, gc.y*cellheight_);

    GNode gl(goal_.x, goal_.y);

    // GNode start(st.x*cellwidth_, st.y*cellheight_);
    // TODO: Need to test it!!!
    GNode start(start_.x,start_.y);

    ROS_INFO("Global Planner --> Start: %d, %d --- Goal: %d, %d ",(int)start.x,(int)start.y,(int)gl.x,(int) gl.y);



    /// STL THETA*

    std::vector<GNode> sol;
    std::vector< std::vector<GNode> > path_sol;
    ThetaStarSearch<GNode> thetastarsearch( false);

    unsigned int SearchCount = 0;

    const unsigned int NumSearches = 1;

    while(SearchCount < NumSearches)
    {



        // Set Start and goal states

        thetastarsearch.SetStartAndGoalStates( start, gl );

        unsigned int SearchState;
        unsigned int SearchSteps = 0;

        do
        {
            SearchState = thetastarsearch.SearchStep();

            SearchSteps++;
#if DEBUG_LISTS

            ROS_INFO("Global Planner --> Steps: %d", (int)SearchSteps);

            int len = 0;

            ROS_INFO("Open:");
            GNode *p = thetastarsearch.GetOpenListStart();
            while( p )
            {
                len++;
#if !DEBUG_LIST_LENGTHS_ONLY
                ((GNode *)p)->PrintNodeInfo();
#endif
                p = thetastarsearch.GetOpenListNext();

            }
            ROS_INFO("Global Planner --> Open list has %d",len);

            len = 0;
            ROS_INFO("Global Planner --> Closed");
            p = thetastarsearch.GetClosedListStart();
            while( p )
            {
                len++;
#if !DEBUG_LIST_LENGTHS_ONLY
                p->PrintNodeInfo();
#endif
                p = thetastarsearch.GetClosedListNext();
            }
            ROS_INFO("Global Planner --> Closed list has %d nodes",len);
#endif
        }
        while( SearchState == ThetaStarSearch<GNode>::SEARCH_STATE_SEARCHING && SearchSteps < MAX_LIMIT_SEARCH_STEPS_);


        if(SearchSteps >= MAX_LIMIT_SEARCH_STEPS_){

            ROS_INFO("Grid Planner !! Search did not find a path, MAX_LIMIT_SEARCH_STEPS_ exceeded!");

        }

        if( SearchState == ThetaStarSearch<GNode>::SEARCH_STATE_SUCCEEDED )
        {
            ROS_INFO("Global Planner --> Search found goal state");

            GNode *node = thetastarsearch.GetSolutionStart();
            int steps = 0;
            int xs,ys;
            node->PrintNodeInfo();
            xs=node->x;
            ys=node->y;
            sol.push_back(GNode(xs,ys));
            ROS_INFO("Global Planner --> Nodes: %d,%d", xs,ys);
            for( ;; )
            {
                node = thetastarsearch.GetSolutionNext();

                if( !node )
                {
                    break;
                }

                node->PrintNodeInfo();

                xs=node->x;
                ys=node->y;
                sol.push_back(GNode(xs,ys));
                ROS_INFO("Global Planner --> Nodes : %d, %d ",xs, ys);

                steps ++;

            };


            // Once you're done with the solution you can free the nodes up
            thetastarsearch.FreeSolutionNodes();


        }
        else if( SearchState == ThetaStarSearch<GNode>::SEARCH_STATE_FAILED )
        {
            ROS_INFO("Global Planner --> Search terminated. Did not find goal state");

        }

        // Display the number of loops the search went through
        ROS_INFO("Global Planner --> SearchSteps: %d ",(int)SearchSteps);

        SearchCount ++;

        thetastarsearch.EnsureMemoryFreed();
    }

    std::reverse(sol.begin(), sol.end());
    paths.push_back(sol);

    int path_size=paths.size();
    ROS_INFO("Global Planner --> Found [ %d ] paths",path_size);

    if (path_size>0){

        	return 1;
    }
    else
    		return 0;

}
Пример #7
0
int main(int argc, char** argv)
{
    glutInit(&argc,argv);
    sofa::helper::parse("This is a SOFA application.")
    (argc,argv);

    sofa::gui::initMain();
    sofa::gui::GUIManager::Init(argv[0]);

    // The graph root node : gravity already exists in a GNode by default
    GNode* groot = new GNode;
    groot->setName( "root" );
    groot->setGravityInWorld( Vec3dTypes::Coord(0,0,0) );
    groot->setDt(0.02);

    /*
     * collision pipeline: instead of calling ObjectCreator
     */
    // collision pipeline
    DefaultPipeline* collisionPipeline = new DefaultPipeline;
    collisionPipeline->setName("Collision Pipeline");
    groot->addObject(collisionPipeline);

    // collision detection system
    BruteForceDetection* collisionDetection = new BruteForceDetection;
    collisionDetection->setName("Collision Detection");
    groot->addObject(collisionDetection);

    // component to detection intersection
    NewProximityIntersection* detectionProximity = new NewProximityIntersection;
    detectionProximity->setName("Detection Proximity");
    detectionProximity->setAlarmDistance(0.3);
    detectionProximity->setContactDistance(0.2);
    groot->addObject(detectionProximity);

    // contact manager
    DefaultContactManager* contactManager = new DefaultContactManager;
    contactManager->setName("Contact Manager");
    contactManager->setDefaultResponseType("default");
    groot->addObject(contactManager);

    // tree collision group
    TreeCollisionGroupManager* collisionGroupManager = new TreeCollisionGroupManager;
    collisionGroupManager->setName("Collision Group Manager");
    groot->addObject(collisionGroupManager);



    /*
     * Sub nodes: DRE
     */
    GNode* dreNode = new GNode;
    dreNode->setName("DRE");


    GNode* cylNode = new GNode;
    cylNode->setName("Cylinder");


    // solvers
    typedef CGLinearSolver<GraphScatteredMatrix, GraphScatteredVector> CGLinearSolverGraph;
    EulerImplicitSolver* implicitSolver = new EulerImplicitSolver;
    CGLinearSolverGraph* cgLinearSolver = new CGLinearSolverGraph;

    implicitSolver->setName("eulerImplicitSolver");
    implicitSolver->f_rayleighStiffness.setValue(0.01);
    //implicitSolver->f_rayleighMass.setValue(0.1);
    implicitSolver->f_printLog = false;
    cgLinearSolver->setName("cgLinearSolver");
    cgLinearSolver->f_maxIter.setValue(25);
    cgLinearSolver->f_tolerance.setValue(1.0e-9);
    cgLinearSolver->f_smallDenominatorThreshold.setValue(1.0e-9);




    // sparse grid topology
    sofa::component::topology::SparseGridTopology* sparseGridTopology = new sofa::component::topology::SparseGridTopology;
    sparseGridTopology->setName("SparseGrid Topology");
    std::string topologyFilename = "mesh/truthcylinder1.obj";
    sparseGridTopology->load(topologyFilename.c_str());
    sparseGridTopology->setN(Vec<3,int>(8, 6, 6));


    // mechanical object
    typedef MechanicalObject< Vec3dTypes > MechanicalObject3d;
    MechanicalObject3d* mechanicalObject = new MechanicalObject3d;
    mechanicalObject->setTranslation(0,0,0);
    mechanicalObject->setRotation(0,0,0);
    mechanicalObject->setScale(1,1,1);


    // mass
    typedef UniformMass< Vec3dTypes,double > UniformMass3d;
    UniformMass3d* uniformMass = new UniformMass3d;
    uniformMass->setTotalMass(5);


    // hexahedron fem forcefield
    typedef HexahedronFEMForceField< Vec3dTypes > HexahedronFEMForceField3d;
    HexahedronFEMForceField3d* hexaFEMFF = new HexahedronFEMForceField3d;
    hexaFEMFF->setName("HexahedronFEM Forcefield");
    hexaFEMFF->setMethod(HexahedronFEMForceField3d::POLAR);
    hexaFEMFF->setPoissonRatio(0.3);
    hexaFEMFF->setYoungModulus(250);


    // quad bending springs
    typedef sofa::component::interactionforcefield::QuadBendingSprings< Vec3dTypes > QuadBendingSprings3d;
    QuadBendingSprings3d* quadBendingSprings = new QuadBendingSprings3d;
    quadBendingSprings->setName("QuadBending springs");
    quadBendingSprings->setStiffness(1000);
    quadBendingSprings->setDamping(1);
    quadBendingSprings->setObject1(mechanicalObject);


    // fixed constraint
    typedef FixedConstraint< StdVectorTypes<Vec<3,double>,Vec<3,double>,double> > FixedConstraint3d;
    FixedConstraint3d* fixedConstraints = new FixedConstraint3d;
    fixedConstraints->setName("Box Constraints");
    fixedConstraints->addConstraint(0);
    fixedConstraints->addConstraint(1); fixedConstraints->addConstraint(2); fixedConstraints->addConstraint(6); fixedConstraints->addConstraint(12); fixedConstraints->addConstraint(17); fixedConstraints->addConstraint(21); fixedConstraints->addConstraint(22);
    fixedConstraints->addConstraint(24); fixedConstraints->addConstraint(25); fixedConstraints->addConstraint(26); fixedConstraints->addConstraint(30); fixedConstraints->addConstraint(36); fixedConstraints->addConstraint(41); fixedConstraints->addConstraint(46); fixedConstraints->addConstraint(47);
    fixedConstraints->addConstraint(50); fixedConstraints->addConstraint(51); fixedConstraints->addConstraint(52); fixedConstraints->addConstraint(56); fixedConstraints->addConstraint(62); fixedConstraints->addConstraint(68); fixedConstraints->addConstraint(73); fixedConstraints->addConstraint(74);
    fixedConstraints->addConstraint(77); fixedConstraints->addConstraint(78); fixedConstraints->addConstraint(79); fixedConstraints->addConstraint(83); fixedConstraints->addConstraint(89); fixedConstraints->addConstraint(95); fixedConstraints->addConstraint(100); fixedConstraints->addConstraint(101);
    fixedConstraints->addConstraint(104); fixedConstraints->addConstraint(105); fixedConstraints->addConstraint(106); fixedConstraints->addConstraint(110); fixedConstraints->addConstraint(116); fixedConstraints->addConstraint(122); fixedConstraints->addConstraint(127); fixedConstraints->addConstraint(128);
    fixedConstraints->addConstraint(131); fixedConstraints->addConstraint(132); fixedConstraints->addConstraint(133); fixedConstraints->addConstraint(137); fixedConstraints->addConstraint(143); fixedConstraints->addConstraint(149); fixedConstraints->addConstraint(154); fixedConstraints->addConstraint(155);
    fixedConstraints->addConstraint(158); fixedConstraints->addConstraint(159); fixedConstraints->addConstraint(160); fixedConstraints->addConstraint(164); fixedConstraints->addConstraint(170); fixedConstraints->addConstraint(175); fixedConstraints->addConstraint(180); fixedConstraints->addConstraint(181);
    fixedConstraints->addConstraint(184); fixedConstraints->addConstraint(185); fixedConstraints->addConstraint(186); fixedConstraints->addConstraint(190); fixedConstraints->addConstraint(196); fixedConstraints->addConstraint(201); fixedConstraints->addConstraint(206); fixedConstraints->addConstraint(205);


    // visual node
    GNode* cylVisualNode = new GNode;
    cylVisualNode->setName("Cylinder Visual");

    OglModel* cylOglModel = new OglModel;
    cylOglModel->setName("Visual");
    std::string visualFilename = "mesh/truthcylinder1.obj";
    cylOglModel->setFilename(DataRepository.getFile(visualFilename).c_str());
    cylOglModel->setColor("red");


    typedef BarycentricMapping< Vec3dTypes, ExtVec3fTypes > BarycentricMapping3d_to_Ext3f;
    BarycentricMapping3d_to_Ext3f* barycentricMapping = new BarycentricMapping3d_to_Ext3f(mechanicalObject, cylOglModel);
    barycentricMapping->setName("Barycentric");
    //barycentricMapping->setPathInputObject("../..");
    //barycentricMapping->setPathOutputObject("Visual");




    // collision node
    GNode* cylCollisionNode = new GNode;
    cylCollisionNode->setName("Cylinder Collision");

    sofa::component::container::MeshLoader* cylSurfMeshLoader = new sofa::component::container::MeshLoader;
    std::string collisionFilename = "mesh/truthcylinder1.msh";
    cylSurfMeshLoader->setFilename(DataRepository.getFile(collisionFilename).c_str());

    MeshTopology* cylSurfaceTopology = new MeshTopology;


    MechanicalObject3d* cylSurfMechanicalObject = new MechanicalObject3d;

    TriangleModel* triangleModel = new TriangleModel;

    typedef BarycentricMapping< Vec3dTypes, Vec3dTypes > BarycentricMechanicalMapping3d_to_3d;
    BarycentricMechanicalMapping3d_to_3d* cylSurfBarycentricMapping = new BarycentricMechanicalMapping3d_to_3d(mechanicalObject, cylSurfMechanicalObject);
    //cylSurfBarycentricMapping->setPathInputObject("../..");
    //cylSurfBarycentricMapping->setPathOutputObject("..");

    cylVisualNode->addObject(cylOglModel);
    cylVisualNode->addObject(barycentricMapping);


    cylCollisionNode->addObject(cylSurfMeshLoader);
    cylCollisionNode->addObject(cylSurfaceTopology);
    cylCollisionNode->addObject(cylSurfMechanicalObject);
    cylCollisionNode->addObject(triangleModel);
    cylCollisionNode->addObject(cylSurfBarycentricMapping);
    quadBendingSprings->setObject2(cylSurfMechanicalObject);


    cylNode->addObject(implicitSolver);
    cylNode->addObject(cgLinearSolver);
    cylNode->addObject(sparseGridTopology);
    cylNode->addObject(mechanicalObject);
    cylNode->addObject(uniformMass);
    cylNode->addObject(hexaFEMFF);
    cylNode->addObject(quadBendingSprings);
    cylNode->addObject(fixedConstraints);

    cylNode->addChild(cylVisualNode);
    cylNode->addChild(cylCollisionNode);

    dreNode->addChild(cylNode);
    groot->addChild(dreNode);
#ifdef SOFA_GPU_CUDA
    sofa::gpu::cuda::mycudaInit();
#endif


    // Init the scene
    sofa::simulation::tree::getSimulation()->init(groot);
    groot->setAnimate(false);
    groot->setShowNormals(false);
    groot->setShowInteractionForceFields(false);
    groot->setShowMechanicalMappings(false);
    groot->setShowCollisionModels(false);
    groot->setShowBoundingCollisionModels(false);
    groot->setShowMappings(false);
    groot->setShowForceFields(true);
    groot->setShowWireFrame(true);
    groot->setShowVisualModels(true);



    //=======================================
    // Run the main loop
    sofa::gui::GUIManager::MainLoop(groot);

    return 0;

}
Пример #8
0
/* Appends an empty DEAT node just after
 * the last NAME, SEX or BIRT node
 */
void GIndiEntry::appendDeathNode() {
    GNode * n = _birthNode ? _birthNode : _sexNode ? _sexNode : _nameNode;
    // Append BIRT node here
    _deathNode = n->insertNext(new GNode(ENTRY_DEATH));
}
Пример #9
0
int
StructProcessor::getFieldSize(GNode* node)
{
	GNode* sizeNode = globalASTTreePointer->findNodeByIndex(node->getProperty("size")->mNodeProperty);
	return Util::stringToInt(sizeNode->getProperty("low")->mStringProperty);
}
Пример #10
0
/**
 * Destructor for node - removes edge controls on incidient edges and disconnects item from scene
 */
GNode::~GNode()
{
    graph()->invalidateRanking();
    if ( ( isEdgeControl() || isEdgeLabel())
         && isNotNullP( firstPred()) 
         && isNotNullP( firstSucc())
         && isNotNullP( firstPred()->pred())
         && isNotNullP( firstSucc()->succ()))
    {
        GRAPH_ASSERTD( areEqP( firstPred()->style(), firstSucc()->style()),
                       "Different styles on the same edge");
        GEdge *e = graph()->newEdge( firstPred()->pred(), firstSucc()->succ());
        e->setStyle( firstPred()->style());
    } else if ( isSimple())
    {
        QList< GNode *> nodes;
        GEdge* edge;
		Marker m = graph()->newMarker();
        for ( edge = firstSucc(); isNotNullP( edge); edge = edge->nextSucc())
        {
            edge->item()->adjust();
            GNode* succ = edge->succ();

            while ( succ->isEdgeControl() || succ->isEdgeLabel())
            {
                assert( isNotNullP( succ->firstSucc()));
                if ( succ->mark( m))
				{
					nodes << succ;
				}
                succ = succ->firstSucc()->succ();
            }
        }
        for ( edge = firstPred(); isNotNullP( edge); edge = edge->nextPred())
        {
            if ( edge->isSelf()) // We've already processed this one in previous loop
				continue;

			edge->item()->adjust();
            GNode* pred = edge->pred();

            while ( pred->isEdgeControl() || pred->isEdgeLabel())
            {
                assert( isNotNullP( pred->firstPred()));
                if ( pred->mark( m))
				{
					nodes << pred;
				}
                pred = pred->firstPred()->pred();
            }
        }
        
        foreach ( GNode *n, nodes)
        {
            graph()->deleteNode( n);
        }
		graph()->freeMarker( m);
    }
Пример #11
0
/**
 * @brief Builds the SOFA physical model and data and instanciates the SofaThread class
 *
 * @param pMesh : pointer to the triangular mesh
 * @param service : pointer to the SofaService object
 */
void SofaBusiness::loadMesh(::fwData::Mesh::sptr pMesh,  ::fwServices::IService::sptr service)
{
    // Default value : 100 millisecond
    timeStepAnimation = 100;

    // Creation du noeud principal (correspond a la scene)
    groot = new GNode;
    groot->setName( "root" );
    groot->setGravityInWorld( Coord3(0,-10,0) );    // on definit la gravite

    // Creation d'un solveur (permet de calculer les nouvelles positions des particules)
    CGImplicitSolver* solver = new CGImplicitSolver;
    groot->addObject(solver);

    // On definit les degres de liberte du Tetrahedre (coordonnees, vitesses...)
    MechanicalObject3* DOF = new MechanicalObject3;
    groot->addObject(DOF);
    DOF->resize(4);
    DOF->setName("DOF");
    VecCoord3& x = *DOF->getX(); // On definit les coordonnees
    x[0] = Coord3(0,10,0);
    x[1] = Coord3(10,0,0);
    x[2] = Coord3(-10*0.5,0,10*0.866);
    x[3] = Coord3(-10*0.5,0,-10*0.866);

    // On definit la masse du Tetrahedre
    UniformMass3* mass = new UniformMass3;
    groot->addObject(mass);
    mass->setMass(2);
    mass->setName("mass");

    // On definit le maillage du Tetrahedre (peut etre compose de lignes, triangles...)
    MeshTopology* topology = new MeshTopology;
    topology->setName("mesh topology");
    groot->addObject( topology );
    topology->addTetra(0,1,2,3);

    // On definit les contraintes du Tetrahedre
    FixedConstraint3* constraints = new FixedConstraint3;
    constraints->setName("constraints");
    groot->addObject(constraints);
    constraints->addConstraint(0);

    // On definit les forces du Tetrahedre
    TetrahedronFEMForceField3* fem = new  TetrahedronFEMForceField3;
    fem->setName("FEM");
    groot->addObject(fem);
    fem->setMethod("polar");
    fem->setUpdateStiffnessMatrix(true);
    fem->setYoungModulus(6);

    // Creation d'un noeud enfant (a la scene) pour accueillir le visuel du fichier .trian
    GNode* skin = new GNode("skin",groot);

    // Creation de la partie visuel du fichier .trian
    OglModelF4S *visual = new OglModelF4S();
    visual->setName( "visual" );
    visual->loadMesh(pMesh);
    visual->setColor("red");
    visual->applyScale(1);
    skin->addObject(visual);

    // Creation du mapping entre les deux objets (effectue une liaison entre deux objets
    // pour que le rendu suive le mouvement de la partie simulation)
    BarycentricMapping3_to_Ext3* mapping = new BarycentricMapping3_to_Ext3(DOF, visual);
    mapping->setName( "mapping" );
    skin->addObject(mapping);

    // Initialisation de la scene
    getSimulation()->init(groot);

    // Create Thread
    meshs = new std::vector<fwData::Mesh::sptr>();
    meshs->push_back(pMesh);
    thread = new SofaThread(this, meshs, service);

    // Translate pointer between sofa and fw4spl
    translationPointer(visual, pMesh);
}
Пример #12
0
void GPath::FindTile(GNode* gnode, int x, int y, int dir) {
  if(TileInBounds(x, y)) {
    //check whether we already have it
    GNode* node = GetNode(x, y);
    if (NULL == node) {     
      int type = GetTileType(x, y);
      if (!IsWrongType(type)) {
	GNode* node = new GNode(x, y);
	node->SetParent(gnode);
	node->CalcF(DestX, DestY, dir);
  	App->Log << "**********\n";
  	App->Log << "Open tile:\n";
	App->Log << "x: " << node->GetX();
	App->Log << " y: " << node->GetY();
	App->Log << " G: " << node->GetG();
	App->Log << " H: " << node->GetH();
	App->Log << " F: " << node->GetF() << std::endl;
	SetNode(node);
	Open.push(node);
      }
    } // null == node
    else if (node->IsOpen()) {      
      //check if this path is better
      int pts;
      if (DIR_HV == dir) 
	pts = PTS_HV;
      else
	pts = PTS_DIAG; 

      if (gnode->GetG() + pts < node->GetG()) {
	node->SetParent(gnode);
	node->CalcF(DestX, DestY, dir);	
      }	
    } //IsOpen()
  } // in bounds
}
Пример #13
0
void ReducibleIfAnalyzer::analyzeNode(GNode *node, const vector<int> &context)
{
    GNode *testingNode = NodeProcessor::getOperand(node, 0);
    GNode *ifIfNode = NodeProcessor::getOperand(node, 2);
    GNode *logicLeftNode, *logicRightNode;
    if(NodeProcessor::isLogicAnd(testingNode))
    {
	logicLeftNode = NodeProcessor::getOperand(testingNode, 0);
	logicRightNode = NodeProcessor::getOperand(testingNode, 1);
	if(NodeProcessor::isCompareOperation(logicLeftNode))
	{
	    LogicUnit temp;
	    if(NULL != logicLeftNode)
		temp.ope = logicLeftNode->getTreeCode();
	    GNode *op0Node = NodeProcessor::getOperand(logicLeftNode, 0);
	    GNode *op1Node = NodeProcessor::getOperand(logicLeftNode, 1);
	    temp.left = NodeProcessor::getSimpleOperation(op0Node);
	    temp.right = NodeProcessor::getSimpleOperation(op1Node);
	    vec_LogicUnit.push_back(temp);
	    if(NodeProcessor::isCompareOperation(logicRightNode))
	    {
		if(NULL != logicRightNode)
		    temp.ope = logicRightNode->getTreeCode();
		GNode *op0Node = NodeProcessor::getOperand(logicRightNode, 0);
		GNode *op1Node = NodeProcessor::getOperand(logicRightNode, 1);
		temp.left = NodeProcessor::getSimpleOperation(op0Node);
		temp.right = NodeProcessor::getSimpleOperation(op1Node);
		vec_LogicUnit.push_back(temp);
	    }
	}
    }
    else
    {
	return ;
    }
    if(NodeProcessor::isCondExpr(ifIfNode))
    {
	GNode *ifIfTesting = NodeProcessor::getOperand(ifIfNode, 0);
	if(NodeProcessor::isCompareOperation(ifIfTesting))
	{
	    LogicUnit temp;
	    if(NULL != ifIfTesting)
	    temp.ope = ifIfTesting->getTreeCode();
	    GNode *op0Node = NodeProcessor::getOperand(ifIfTesting, 0);
	    GNode *op1Node = NodeProcessor::getOperand(ifIfTesting, 1);
	    temp.left = NodeProcessor::getSimpleOperation(op0Node);
	    temp.right = NodeProcessor::getSimpleOperation(op1Node);
	    vec_LogicUnit.push_back(temp);
	    GNode *ifIfElseNode = NodeProcessor::getOperand(ifIfNode, 2);
	    if(NodeProcessor::isCondExpr(ifIfElseNode))
	    {
		if(vec_LogicUnit[0].anti(vec_LogicUnit[2]))
		{
		    int lineNum;
		    if(NULL != node)
			lineNum = Util::stringToInt(node->getProperty("line")->mStringProperty);
		    Logger::a("ReducibleAnalyzer") << "if statement is reducible" \
			<< SrcManager::getInstance().getFullFileName() << lineNum \
			<< SrcManager::getInstance().getLine(lineNum) << endl;
		    stringstream reportMsgStream;
		    reportMsgStream << "ReducibleAnalyzer: if statement is reducible" << endl;
		    string reportMsg = reportMsgStream.str();
		    ReportManager::getInstance().insertReport(SrcManager::getInstance().getFullFileName(), lineNum, reportMsg);
		}
	    }
	}
    }
}
/**********************************************************************
 * displayLevel - level order traversal and display
 ***********************************************************************/
void displayLevel(GNode* &aHead)
{
    const int MAX = 150;
    GNode* queue[MAX];
    GNode* temp = aHead;
    int front = 0;
    int back = 0;
    int saveBack = 1;
    int generation = 0;
    bool showGeneration = true;

    while (temp->getINum() != "I1")
        temp = temp->getNext();

    queue[back++] = temp;
    cout << "The Ancestors of " << temp->getFName() << " " << temp->getLName() << ":" << endl;
    while (front != back)
    {
        temp = queue[front];
        if (front == saveBack)
        {
            generation++;
            saveBack = back;
            if (generation == 1)
                cout << "Parents:" << endl;
            else if (generation == 2)
                cout << "Grandparents:" << endl;
            else if (generation == 3)
                cout << "Great Grandparents:" << endl;
            else if (generation == 4)
                cout << "2nd Great Grandparents:" << endl;
            else if (generation == 5)
                cout << "3rd Great Grandparents:" << endl;
            else if (generation == 6)
                cout << "4th Great Grandparents:" << endl;
            else if (generation == 7)
                cout << "5th Great Grandparents:" << endl;
        }

        front = (front + 1) % MAX;

        if (temp != NULL)
        {
            if (front != 1)
            {
                cout << "        ";
                if (temp->getFName() != "")
                    cout << temp->getFName();
                if (temp->getLName() != "" && temp->getFName() != "")
                    cout << " " << temp->getLName();
                else
                    cout << temp->getLName();

                if (temp->getDay() != "" || temp->getMonth() != ""
                        || temp->getYear() != "")
                    cout<< ", b. ";
                if (temp->getDay() != "")
                    cout << temp->getDay() << " ";
                if (temp->getMonth() != "")
                    cout << temp->getMonth() << " ";
                if (temp->getYear() != "")
                    cout << temp->getYear();
                cout << endl;
            }

            queue[back] = temp->getFather();
            back = (back + 1) % MAX;
            queue[back] = temp->getMother();
            back = (back + 1) % MAX;
        }
    }
}
/**********************************************************************
 * displayList - displays a linked list, starting with the head argument.
 ***********************************************************************/
void displayList(GNode* &aHead)
{
    GNode* ptr = aHead;

    while (ptr != NULL)
    {
        if (ptr->getFName() != "")
            cout << ptr->getFName();
        if (ptr->getLName() != "" && ptr->getFName() != "")
            cout << " " << ptr->getLName();
        else
            cout << ptr->getLName();

        if (ptr->getDay() != "" || ptr->getMonth() != "" || ptr->getYear() != "")
            cout<< ", b. ";
        if (ptr->getDay() != "")
            cout << ptr->getDay() << " ";
        if (ptr->getMonth() != "")
            cout << ptr->getMonth() << " ";
        if (ptr->getYear() != "")
            cout << ptr->getYear();
        cout << endl;
        ptr = ptr->getNext();
    }
}
/**********************************************************************
 * insert - a sorted insertion
 ***********************************************************************/
void insert(GNode* &listHead, GNode* &aPtr)
{
    //aPtr not rdy to be inserted. Occurs on first individual in parseFile()
    if(aPtr == NULL)
        return;
    //first insertion
    if(listHead == NULL)
    {
        listHead = aPtr;
        return;
    }

    string tempLName = aPtr->getLName();
    string ptrLName;

    for (int i = 0; i < tempLName.length(); i++)
        ptrLName += toupper(tempLName[i]);

    tempLName = listHead->getLName();
    string headLName;
    for (int i = 0; i < tempLName.length(); i++)
        headLName += toupper(tempLName[i]);

    // head insert
    if (ptrLName < headLName)
    {
        aPtr->setNext(listHead);
        listHead = aPtr;
        return;
    }
    else if (ptrLName == headLName && aPtr->getFName() < listHead->getFName())
    {
        aPtr->setNext(listHead);
        listHead = aPtr;
        return;
    }

    GNode* p = listHead;
    GNode* c = listHead->getNext();
    string cLName;

    //traverse, comparing last names,then first Name, then date
    while (c != NULL)
    {
        tempLName = c->getLName();
        cLName.clear();
        for (int i = 0; i < tempLName.length(); i++)
            cLName += toupper(tempLName[i]);

        if (ptrLName > cLName)
        {
            p = c;
            c = c->getNext();
        }
        else if (ptrLName == cLName && aPtr->getFName() > c->getFName())
        {
            p = c;
            c = c->getNext();
        }
        else if (ptrLName == cLName && aPtr->getFName() == c->getFName()
                 && aPtr->getYear() > c->getYear())
        {
            p = c;
            c = c->getNext();
        }
        else
            break;
    }
    p->setNext(aPtr);
    aPtr->setNext(c);
}
/**********************************************************************
 * parseFile -
 ***********************************************************************/
void parseFile(ifstream &inFile, GNode* &aHead)
{
    GNode* ptr = NULL; // traversal pointer

    string temp1; // assign every word in file to temp1
    string temp2; // helper string in parse logic
    int i = 0;
    while (true)
    {
        getline (inFile, temp1);

        if (temp1 == "1 DIV Y")
            break;

        temp2 = temp1.substr(0, 4); // create substring

        //We've reached a new node. Insert previous Node, then start new Node.
        if (temp2 == "0 @I")
        {
            insert(aHead, ptr);
            temp2.clear();
            temp1.erase(0, 3);
            //create INum string
            while (temp1[0] != '@')
            {
                temp2 += temp1[0];
                temp1.erase(0,1);
            }

            ptr = new GNode;
            ptr->setINum(temp2);
        }
        //parse and store first Name
        else if (temp2 == "2 GI")
        {
            temp1.erase(0,7);
            ptr->setFName(temp1);
        }
        //parse and store last Name
        else if (temp2 == "2 SU")
        {
            temp1.erase(0, 7);
            ptr->setLName(temp1);
        }
        //parse and store Birth Date
        else if (temp2 == "1 BI")
        {
            getline(inFile, temp1);
            if (temp1.find("DATE") != std::string::npos) // make sure date exists
            {
                temp1.erase(0,7);
                temp2.clear();
                if (temp1.length() != 0)
                {
                    for (int i = 0; i < temp1.length(); i++)
                    {
                        if (isalpha(temp1[i]))
                        {
                            temp2 += temp1[i];
                            temp1.erase(i, 1);
                            i--;
                        }
                    }
                    ptr->setMonth(temp2);
                    temp2.erase();
                    if (temp1[0] == ' ')
                        temp1.erase(0, 1);

                    while (temp1.length() != 0 && (isdigit(temp1[0])
                                                   || temp1[0] == '/'))
                    {
                        temp2 += temp1[0];
                        temp1.erase(0, 1);
                    }
                    if (temp2.length() > 2)
                        ptr->setYear(temp2);
                    else
                        ptr->setDay(temp2);

                    if (temp1.length() != 0)
                    {
                        temp1.erase(0, 2);
                        temp2.clear();

                        while (temp1.length() != 0)
                        {
                            temp2 += temp1[0];
                            temp1.erase(0, 1);
                        }
                        ptr->setYear(temp2);
                    }
                }
            }
        }
    }
    insert(aHead, ptr);

    // Start Algorithm to Build Binary Tree

    string fatherINum;
    string motherINum;
    string childINum;;

    ptr = aHead; // reset traversal pointer. Use to traverse children
    GNode* ptr2 = ptr; // another traversal pointer. Use to traverse to parents.
    while (true)
    {
        getline(inFile, temp1);

        if (temp1 == "1 CALN 0567673")
            break;

        temp2 = temp1.substr(0, 4); // create substring

        if (temp2 == "1 HU") // check for father
        {
            temp1.erase(0,8);
            temp2.clear();
            while (temp1[0] != '@')
            {
                temp2 += temp1[0];
                temp1.erase(0,1);
            }
            fatherINum = temp2;
        }
        else if (temp2 == "1 WI") // check for mother
        {
            temp1.erase(0,8);
            temp2.clear();
            while (temp1[0] != '@')
            {
                temp2 += temp1[0];
                temp1.erase(0,1);
            }
            motherINum = temp2;
        }
        else if (temp2 == "1 CH") // node whose mother/father need to be set
        {
            temp1.erase(0,8);
            temp2.clear();
            while (temp1[0] != '@')
            {
                temp2 += temp1[0];
                temp1.erase(0,1);
            }
            childINum = temp2;

            ptr = aHead;
            ptr2 = aHead;
            while (childINum != ptr->getINum())
                ptr = ptr->getNext();

            while (fatherINum != "" && fatherINum != ptr2->getINum())
                ptr2 = ptr2->getNext();

            if (fatherINum != "")
                ptr->setFather(ptr2);

            ptr2 = aHead;
            while (motherINum != "" && motherINum != ptr2->getINum())
                ptr2 = ptr2->getNext();

            if (motherINum != "")
                ptr->setMother(ptr2);

            fatherINum.clear();
            motherINum.clear();
        }
    }
}
Пример #18
0
void 
EdgeItem::keyPressEvent(QKeyEvent *event)
{
    int key = event->key();
    GNode *n = NULL;
    GEdge *e = NULL;
    VEdge vedge( edge());
    NavSector sector = edge()->graph()->nodeNavigationSector();
    GNode *curr_node = edge()->graph()->nodeInFocus();
    NodeNav node_nav( curr_node, sector);
    switch( key)
    {
        case Qt::Key_Up:
            if ( isNotNullP( curr_node) 
                 && ( sector == LEFT_SECTOR || sector == RIGHT_SECTOR))
            {
                e = node_nav.edgeInDir( edge(), NAV_DIR_UP);
            } else
            {
                n = vedge.nodeUp();
            }
            break;
        case Qt::Key_Down:
            if ( isNotNullP( curr_node) 
                 && ( sector == LEFT_SECTOR || sector == RIGHT_SECTOR) )
            {
                e = node_nav.edgeInDir( edge(), NAV_DIR_DOWN);
            } else
            {
                n = vedge.nodeDown();
            }
            break;
        case Qt::Key_Left:
            if ( isNotNullP( curr_node) 
                 && ( sector == TOP_SECTOR || sector == BOTTOM_SECTOR) )
            {
                e = node_nav.edgeInDir( edge(), NAV_DIR_LEFT);
            } else
            {
                n = vedge.nodeLeft();
            }
            break;
        case Qt::Key_Right:
            if ( isNotNullP( curr_node) 
                 && ( sector == TOP_SECTOR || sector == BOTTOM_SECTOR) )
            {
                e = node_nav.edgeInDir( edge(), NAV_DIR_RIGHT);
            } else
            {
                n = vedge.nodeRight();
            }
            break;
        default:
            break;
    }
    if ( isNotNullP( n))
    {
        if ( edge()->graph()->view()->isContext())
        {
            edge()->graph()->emptySelection();
            edge()->graph()->selectNode( n);
            edge()->graph()->view()->findContext();
        }
        edge()->graph()->view()->focusOnNode( n, true);
        
        scene()->clearFocus();
        scene()->clearSelection();
        n->item()->setFocus();
        n->item()->setSelected( true);
    } else if ( isNotNullP( e))
    {
        // Get focus on edge
        scene()->clearFocus();
        scene()->clearSelection();
        e->item()->setFocus();
        e->item()->setSelected( true);
    }
    //QGraphicsItem::keyPressEvent( event);
}
Пример #19
0
string
StructProcessor::getFieldName(GNode* node)
{
	GNode* idNode = globalASTTreePointer->findNodeByIndex(node->getProperty("name")->mNodeProperty);
	return idNode->getProperty("strg")->mStringProperty;
}