コード例 #1
0
PatriciaTrieNode<S,T>* PatriciaTrie<S,T>::find_bitindex_node (PatriciaTrieNode<S,T>* root, int bitindex) {
  
  //
  // is the head-pseudo-node requested?
  //

  if (bitindex == -1)
    return head;

  //
  // check all the normal nodes
  //

  NODE_LIST nodes = GetNodeList (root);
  
  NODE_LIST_ITERATOR i  = nodes.begin ();
  NODE_LIST_ITERATOR iend = nodes.end   ();

  for ( ; i != iend; i++) {
    PatriciaTrieNode<S,T>* node = *i;
    if (node->bit_index == bitindex) return node;
  }

  return NULL;
}
コード例 #2
0
bool X3D_MODEL_PARSER::Load( const wxString& aFilename )
{
    wxLogTrace( traceX3DParser, wxT( "Loading: %s" ), GetChars( aFilename ) );

    wxXmlDocument doc;

    if( !doc.Load( aFilename ) )
    {
        wxLogTrace( traceX3DParser, wxT( "Error while parsing file: %s" ), GetChars( aFilename ) );
        return false;
    }

    if( doc.GetRoot()->GetName() != wxT( "X3D" ) )
    {
        wxLogTrace( traceX3DParser, wxT( "Filetype is not X3D: %s" ), GetChars( aFilename ) );
        return false;
    }

    // Switch the locale to standard C (needed to print floating point numbers)
    LOCALE_IO toggle;

    childs.clear();

    // Shapes are inside of Transform nodes
    // Transform node contains information about
    // transition, scale and rotation of the shape
    NODE_LIST transforms;
    GetChildsByName( doc.GetRoot(), wxT( "Transform" ), transforms );

    for( NODE_LIST::iterator node_it = transforms.begin();
         node_it != transforms.end();
         node_it++ )
    {
        m_model.reset( new S3D_MESH() );
        childs.push_back( m_model );

        wxXmlNode* node = *node_it;
        wxXmlAttribute* prop = node->GetAttributes();

        wxLogTrace( traceX3DParser, wxT( "Transform: %s %s" ), prop->GetName(), prop->GetValue() );

        readTransform( node );


    }

    return true;
}
コード例 #3
0
void X3D_MODEL_PARSER::readTransform( wxXmlNode* aTransformNode )
{
    NODE_LIST childnodes;

    GetChildsByName( aTransformNode, wxT( "Material" ), childnodes );

    for( NODE_LIST::iterator node = childnodes.begin();
         node != childnodes.end();
         node++ )
    {
        readMaterial( *node );
    }

    childnodes.clear();

    PROPERTY_MAP properties;

    GetNodeProperties( aTransformNode, properties );



    GetChildsByName( aTransformNode, wxT( "IndexedFaceSet" ), childnodes );

    for( NODE_LIST::iterator node = childnodes.begin();
         node != childnodes.end();
         node++ )
    {
        readIndexedFaceSet( *node, properties );
    }

    childnodes.clear();
}
コード例 #4
0
typename PatriciaTrie<S,T>::NODE_LIST PatriciaTrie<S,T>::GetNodeList (PatriciaTrieNode<S,T>* root) {

  NODE_LIST       retNodes;
  NODE_LIST       newItemsLeft, newItemsRight;
  PatriciaTrieNode<S,T>*  startNode = (root == NULL ? head : root);

  //
  // insert the current node if it is not the root node
  //

  if (startNode->bit_index >= 0)
    retNodes.insert (retNodes.end (), startNode);

  //
  // walk down left wing
  //

  if (startNode->left != NULL && startNode->left->bit_index > startNode->bit_index) 
    newItemsLeft = GetNodeList (startNode->left);
  
  retNodes.insert (retNodes.end(), newItemsLeft.begin(), newItemsLeft.end());

  //
  // walk down right wing
  //

  if (startNode->right != NULL && startNode->right->bit_index > startNode->bit_index)
    newItemsRight = GetNodeList (startNode->right);

  retNodes.insert (retNodes.end(), newItemsRight.begin(), newItemsRight.end());

  return retNodes;
}
コード例 #5
0
/* Steps:
 * 1. Read transform data
 * 2. Read vertex triplets
 * 3. Read coordinate indexes
 * 4. Apply geometry to Master object
 */
void X3D_MODEL_PARSER::readIndexedFaceSet( wxXmlNode* aFaceNode,
        PROPERTY_MAP& aTransformProps )
{
    /* Step 1: Read transform data
     * --------------------------- */

    S3D_VERTEX translation;

    parseDoubleTriplet( aTransformProps[ wxT( "translation" ) ], translation );

    S3D_VERTEX scale;
    parseDoubleTriplet( aTransformProps[ wxT( "scale" ) ], scale );

    S3D_VERTEX rotation;
    double angle = 0.0;
    wxStringTokenizer tokens( aTransformProps[ wxT( "rotation" ) ] );

    double x = 0.0, y = 0.0, z = 0.0;

    if( !( tokens.GetNextToken().ToDouble( &x )
           && tokens.GetNextToken().ToDouble( &y )
           && tokens.GetNextToken().ToDouble( &z )
           && tokens.GetNextToken().ToDouble( &angle ) ) )
    {
        // DBG( printf( "rotation read error" ) );
    }
    else
    {
        rotation.x  = x;
        rotation.y  = y;
        rotation.z  = z;
    }

    /* Step 2: Read all coordinate points
     * ---------------------------- */
    std::vector<double> points;
    NODE_LIST coordinates;
    GetChildsByName( aFaceNode, wxT( "Coordinate" ), coordinates );

    PROPERTY_MAP coordinate_properties;
    // IndexedFaceSet has one Coordinate child node
    GetNodeProperties( coordinates[0], coordinate_properties );

    // Save points to vector as doubles
    wxStringTokenizer point_tokens( coordinate_properties[ wxT( "point" ) ] );
    double point = 0.0;

    while( point_tokens.HasMoreTokens() )
    {
        if( point_tokens.GetNextToken().ToDouble( &point ) )
        {
            points.push_back( point );
        }
        else
        {
            wxLogTrace( traceX3DParser, wxT( "Error converting to double" ) );
        }
    }

    if( points.size() % 3 != 0 )
    {
        // DBG( printf( "Number of points is incorrect" ) );
        return;
    }

    /* Create 3D vertex from 3 points and
     * apply transforms in order of SCALE, ROTATION, TRANSLATION
     */
    wxString vrml_pointlist;
    std::vector<S3D_VERTEX> triplets;

    for( unsigned id = 0; id < points.size() / 3; id++ )
    {
        int triplet_indx = id * 3;
        S3D_VERTEX point( points[ triplet_indx ],
                points[ triplet_indx + 1 ],
                points[ triplet_indx + 2 ] );

        point.x *= scale.x;
        point.y *= scale.y;
        point.z *= scale.z;

        rotate( point, rotation, angle );

        point.x += translation.x;
        point.y += translation.y;
        point.z += translation.z;

        m_model->m_Point.push_back( point );

        // VRML
        vrml_pointlist.Append( wxString::Format( wxT( "%f %f %f\n" ), point.x, point.y, point.z ) );
    }

    vrml_points.push_back( vrml_pointlist );


    /* Step 3: Read all color points
     * ---------------------------- */
    std::vector<double> color_points;
    NODE_LIST color;
    GetChildsByName( aFaceNode, wxT( "Color" ), color );

    // Some models lack color information, need to handle this safely
    if( !color.empty() )
    {
        PROPERTY_MAP color_properties;
        // IndexedFaceSet has one Coordinate child node
        GetNodeProperties( color[0], color_properties );

        // Save points to vector as doubles
        wxStringTokenizer colorpoint_tokens( color_properties[ wxT( "color" ) ] );
        double color_point = 0.0;

        while( colorpoint_tokens.HasMoreTokens() )
        {
            if( colorpoint_tokens.GetNextToken().ToDouble( &color_point ) )
            {
                color_points.push_back( color_point );
            }
            else
            {
                wxLogTrace( traceX3DParser, wxT( "Error converting to double" ) );
            }
        }

        if( color_points.size() % 3 != 0 )
        {
            // DBG( printf( "Number of points is incorrect" ) );
            return;
        }

        /* Create 3D face color from 3 color points
         */
        m_model->m_Materials->m_DiffuseColor.clear();

        for( unsigned id = 0; id < color_points.size() / 3; id++ )
        {
            m_model->m_MaterialIndexPerFace.push_back( id );

            int color_triplet_indx = id * 3;
            glm::vec3 colorface( color_points[ color_triplet_indx + 0 ],
                    color_points[ color_triplet_indx + 1 ],
                    color_points[ color_triplet_indx + 2 ] );

            m_model->m_Materials->m_DiffuseColor.push_back( colorface );
        }
    }


    /* -- Read coordinate indexes -- */
    PROPERTY_MAP faceset_properties;
    GetNodeProperties( aFaceNode, faceset_properties );

    wxString coordIndex_str = faceset_properties[ wxT( "coordIndex" ) ];
    wxStringTokenizer index_tokens( coordIndex_str );

    wxString vrml_coord_indx_list;

    std::vector<int> coord_list;
    coord_list.clear();

    while( index_tokens.HasMoreTokens() )
    {
        long index = 0;

        index_tokens.GetNextToken().ToLong( &index );

        // -1 marks the end of polygon
        if( index < 0 )
        {
            /* Step 4: Apply geometry to Master object
             * --------------------------------------- */
            m_model->m_CoordIndex.push_back( coord_list );

            coord_list.clear();
            vrml_coord_indx_list.Append( wxT( "-1\n" ) );
        }
        else
        {
            coord_list.push_back( index );
            vrml_coord_indx_list.Append( wxString::Format( wxT( "%ld " ), index ) );
        }
    }

    vrml_coord_indexes.push_back( vrml_coord_indx_list );
}
コード例 #6
0
PatriciaTrie<S,T>* PatriciaTrie<S,T>::Copy (PatriciaTrieNode<S,T>* root) {

  PatriciaTrieNode<S,T>* newNode = new PatriciaTrieNode<S,T> ();
  bool recursiveHead = (root == NULL);
  if (root == NULL) root = head;

  newNode->bit_index  = root->bit_index;
  newNode->data   = root->data;
  newNode->key    = root->key;

  //
  // create the subtrees and wire my children to it
  // or (if there are no subtrees) wire the children to myself
  // later we will wire the children correctly with some backedges
  //

  if (root->left != NULL && root->left->bit_index > root->bit_index) {
    PatriciaTrie<S,T>* leftTrie = Copy (root->left);
    newNode->left = leftTrie->head;
    leftTrie->head = NULL;
    delete leftTrie;
  } else {
    newNode->left = newNode;
  }

  if (root->right != NULL && root->right->bit_index > root->bit_index) {
    PatriciaTrie<S,T>* rightTrie = Copy (root->right);
    newNode->right = rightTrie->head;
    rightTrie->head = NULL;
    delete rightTrie;
  } else {
    newNode->right = newNode;
  }

  PatriciaTrie<S,T>* newTrie = new PatriciaTrie<S,T> ();
  newTrie->head = newNode;

  //
  // need to adapt the back edges
  //

  if (recursiveHead) {

    NODE_LIST origNodes = GetNodeList ();
    NODE_LIST newNodes  = newTrie->GetNodeList ();

    assert (origNodes.size() == newNodes.size());

    NODE_LIST_ITERATOR iorigBegin = origNodes.begin ();
    NODE_LIST_ITERATOR iorigEnd   = origNodes.end   ();
    NODE_LIST_ITERATOR inewBegin  = newNodes.begin  ();
    NODE_LIST_ITERATOR inewEnd    = newNodes.end    ();

    for ( ; iorigBegin != iorigEnd && inewBegin != inewEnd; iorigBegin++, inewBegin++) {
      
      PatriciaTrieNode<S,T>* origNode = *iorigBegin;
      PatriciaTrieNode<S,T>* newNode  = *inewBegin;

      //
      // make some checks that everything went fine
      //

      assert (origNode      != newNode        && 
          origNode->key     == newNode->key     &&
          origNode->bit_index == newNode->bit_index &&
          origNode->data      == newNode->data    );

      //
      // if the original node has backedges:
      // find the correct backedge node in the new trie
      // and wire the children correctly
      //

      if (origNode->left->bit_index < origNode->bit_index)
        newNode->left = newTrie->find_bitindex_node (newTrie->head, origNode->left->bit_index); 
      
      if (origNode->right->bit_index < origNode->bit_index)
        newNode->right = newTrie->find_bitindex_node (newTrie->head, origNode->right->bit_index); 
    
    } // for ( ; iorigBegin != iorigEnd && inewBegin != inewEnd; iorigBegin++, inewBegin++) 
  
  } // if (recursiveHead)

  return newTrie;
}