C++ SoInput::closeFile方法代码示例

SoSeparator* loadModel(const char* fileName)
{
  SoSeparator *root = new SoSeparator;
  SoInput myScene;

  //try to open the file
  if (!myScene.openFile(fileName)) {
    printf("Could not open %s\n",fileName) ;
    return NULL;
  } 
        
  //check if the file is valid
  if (!myScene.isValidFile()) {
    printf("%s is not a valid Inventor file\n",fileName) ;
    return NULL;
  }

  //try to read the file
  root = SoDB::readAll(&myScene) ;
  
  if (root == NULL) {
    printf("Problem reading %s\n",fileName) ;
    myScene.closeFile() ;
    return NULL;
  }

  //close the file
  myScene.closeFile() ;
  
  return root ;
}

SoSeparator *
SceneFileObj::readSceneFile(void)
{
    SoInput input;
    SoSeparator *s;
    FILE *f = NULL;

    if (_sceneFileName[0] == '<') {
	char *p = _sceneFileName+1;

	while (*p) {
	    if (! isdigit(*p))
		break;
	    p++;
	}

	if (*p == '\0') {
	    int fd = atoi(_sceneFileName+1);

	    if ((f = fdopen(fd, "r")) == NULL) {
		return (NULL);
	    }
	    input.setFilePointer(f);
	}
    }

    if (f == NULL) {
	if (!input.openFile(_sceneFileName))
	    return NULL;
    }
    s = SoDB::readAll(&input);
    input.closeFile();

    return s;
}

TSeparatorKit* ComponentHeliostatField::OpenHeliostatComponent( QString fileName )
{
	if ( fileName.isEmpty() ) return 0;

	SoInput componentInput;
	if ( !componentInput.openFile( fileName.toLatin1().constData() ) )
	{
        QMessageBox::warning( 0, QString( "Scene Graph Structure" ),
        		QString( "Cannot open file %1:\n." ).arg( fileName ) );
		return 0;
	}

	SoSeparator* componentSeparator = SoDB::readAll( &componentInput );
	componentInput.closeFile();

	if ( !componentSeparator )
	{
        QMessageBox::warning( 0, QString( "Scene Graph Structure" ),
        		QString( "Error reading file %1:\n%2." )
                             .arg( fileName ) );
		return 0;
	}

	TSeparatorKit* componentRoot = static_cast< TSeparatorKit* >( componentSeparator->getChild(0) );
	componentRoot->ref();


   return componentRoot;

}

/*!
 * Reads the scene saved on the file with given \a filename and return a pointer to the scene.
 *
 * Returns null on any error.
 */
TSceneKit* Document::GetSceneKitFromFile( const QString& fileName )
{
    SoInput sceneInput;
	if ( !sceneInput.openFile( fileName.toLatin1().constData() ) )
	{
		QString message = QString( "Cannot open file %1." ).arg( fileName );
		emit Warning( message );

		return 0;
	}

	if( !sceneInput.isValidFile() )
	{
		QString message = QString( "Error reading file %1.\n" ).arg( fileName );
		emit Warning( message );

		return 0;
	}

	SoSeparator* graphSeparator = SoDB::readAll( &sceneInput );
	sceneInput.closeFile();

	if ( !graphSeparator )
	{
		QString message = QString( "Error reading file %1.\n" ).arg( fileName );
		emit Warning( message );

		return 0;
	}

   return static_cast< TSceneKit* >( graphSeparator->getChild(0) );
	return 0;
}

SoSeparator *ReadScene(const char *Dir, const char *filename) {
   FILE *filePtr = NULL;
   SoSeparator *root;
   SoInput in;

   in.addDirectoryLast(Dir);

   if (!in.openFile(filename)) {
       cerr << "Error opening file " << filename << " from Directory " << Dir 
	    << endl;
       exit(1);
   }
   
   root = SoDB::readAll(&in);
   if (root == NULL)
       cerr << "Error reading file " << filename << " from Directory " << Dir 
	    << endl;
   else {
#ifdef DEBUG
       cerr << "Scene (" << filename << ") read!\n";
#endif
       root->ref();
   }
   in.closeFile();
   return root;
}

SoSeparator* QilexDoc::readFile(const char *filename, int &tipus)
{
   // Open the input file
   SoInput mySceneInput;
   if (!mySceneInput.openFile(filename)) {
      fprintf(stderr, "Cannot open file %s\n", filename);
      return NULL;
   }

   // Read the whole file into the database
   SoSeparator *myGraph = SoDB::readAll(&mySceneInput);
   tipus = (int)mySceneInput.isFileVRML2();

   if (myGraph == NULL) {
      fprintf(stderr, "Problem reading file\n");
      return NULL;
   }
   mySceneInput.closeFile();
   return myGraph;
}

bool InventorViewer::loadModel(const std::string& filename)
{
    if (!initialized)
    {
      ROS_ERROR("InventorViewer not initialized.");
      return false;
    }
    SoInput in;
    SoNode  *model = NULL;
    if (!in.openFile(filename.c_str()))
        return false;
    if (!SoDB::read(&in, model) || model == NULL)
        /*model = SoDB::readAll(&in);
        if (!model)*/
        return false;

    root->addChild(model);
    in.closeFile();
    return true;
}

SbBool
SoTexture2::readImage(const SbString& fname, int &w, int &h, int &nc, 
		      unsigned char *&bytes)
//
////////////////////////////////////////////////////////////////////////
{
    w = h = nc = 0;
    bytes = NULL;
    
    // Empty file means an empty image...
    if (fname.getString()[0] == '\0')
	return TRUE;

    SoInput in;
    if (!in.openFile(fname.getString(), TRUE)) {
	return FALSE;
    }

#ifdef DEBUG
    SoDebugError::postInfo("SoTexture2::readImage",
			   "Reading texture image %s",
			   fname.getString());
#endif

    if (ReadSGIImage(in, w, h, nc, bytes))
	return TRUE;

    // fiopen() closes the file even if it can't read the data, so 
    // reopen it
    in.closeFile();
    if (!in.openFile(fname.getString(), TRUE))
	return FALSE;

    if (ReadGIFImage(in, w, h, nc, bytes))
	return TRUE;

    if (ReadJPEGImage(in, w, h, nc, bytes))
	return TRUE;

    return FALSE;
}

void
SoFile::nameChangedCB(void *data, SoSensor *)
//
////////////////////////////////////////////////////////////////////////
{
    SoFile *f = (SoFile *)data;

    f->children.truncate(0);

    SoInput in;
    const char *filename = f->name.getValue().getString();
    
    // Open file
    f->readOK = TRUE;
    if (! in.openFile(filename, TRUE)) {
	f->readOK = FALSE;
	SoReadError::post(&in, "Can't open included file \"%s\" in File node",
			  filename);
    }

    if (f->readOK) {
	SoNode	*node;

	// Read children from opened file.

	while (TRUE) {
	    if (SoDB::read(&in, node)) {
		if (node != NULL)
		    f->children.append(node);
		else
		    break;
	    }
	    else
		f->readOK = FALSE;
	}
	in.closeFile();
    }
    // Note: if there is an error reading one of the children, the
    // other children will still be added properly...
}

void SoFileSubgraph::readFile(const char *fileName){

    // open the input file
    SoInput sceneInput;
    if (!sceneInput.openFile(fileName)) {
		SoDebugError::post("SoFileSubgraph::readFile()",
				"Cannot open file '%s'",
				fileName);
        return;
    }
    if (!sceneInput.isValidFile()){
		SoDebugError::post("SoFileSubgraph::readFile()",
				"file '%s' is not a valid Inventor file",
				fileName);
       return;
    }
    else{
		SoDebugError::postInfo("SoFileSubgraph::readFile()",
				"file '%s' read successfully",
				fileName);
    }

    // read the whole file into the database
    SoSeparator *subgraph=SoDB::readAll(&sceneInput);
    subgraph->ref();
    if (subgraph ==NULL) {
		SoDebugError::post("SoFileSubgraph::readFile()",
				"problem reading contents of file '%s'",
				fileName);
        return;
    }
    SoSeparator *graphRoot=SO_GET_ANY_PART(this,"root",SoSeparator);
    graphRoot->addChild(subgraph);

    sceneInput.closeFile();
}

/*!
  Tries to load the shape primitives file for the grasped object.  It uses
  the same file name as the current object, but looks in the primitives folder
  within the objects directory. If the primitives are not found, it uses
  the original geometry of the object, the \a IVGeomRoot.  
*/
void
grasp_manager::loadPrimitives()
{
 
  SoInput myInput;
  char prDir[256];
  QString directory = QString(getenv("GRASPIT"))+
    QString("/models/objects/primitives/");
  QString filename = my_body->getFilename().section('/',-1);
  //make sure the extension is iv, as this is how primitives
  //are stored for now
  filename = filename.section('.',-2,-2) + ".iv";
  QString path = directory + filename;

  printf("Loading primitive %s.\n",path.latin1());

  if (!(myInput.openFile(path.latin1()))) {
    pr_error("could not open primitives file!");
    primitives = my_body->getIVGeomRoot();
    printf ("%s\n",prDir);
    printf("Setting primitive root node to original object.\n");
  }
  else {
      primitives = SoDB::readAll(&myInput);
	  myInput.closeFile();
      if (primitives == NULL) {
	  printf("Load Primitive didnt work, although file seems to exist.\n");
	  printf("Setting primitive root node to original object.\n");
	  primitives = my_body->getIVGeomRoot();
      }
      else {
	primitives->ref();
      }
  }

}

/**
 * Read from SoInput and convert to OSG.
 * This is a method used by readNode(string,options) and readNode(istream,options).
 */
osgDB::ReaderWriter::ReadResult
ReaderWriterIV::readNodeFromSoInput(SoInput &input,
          std::string &fileName, const osgDB::ReaderWriter::Options *options) const
{
    // Parse options and add search paths to SoInput
    const osgDB::FilePathList *searchPaths = options ? &options->getDatabasePathList() : NULL;
    if (options)
        addSearchPaths(searchPaths);

    // Create the inventor scenegraph by reading from SoInput
    SoSeparator* rootIVNode = SoDB::readAll(&input);

    // Remove recently appened search paths
    if (options)
        removeSearchPaths(searchPaths);

    // Close the file
    input.closeFile();

    // Perform conversion
    ReadResult result;
    if (rootIVNode)
    {
        rootIVNode->ref();
        // Convert the inventor scenegraph to an osg scenegraph
        ConvertFromInventor convertIV;
        convertIV.preprocess(rootIVNode);
        result = convertIV.convert(rootIVNode);
        rootIVNode->unref();
    } else
        result = ReadResult::FILE_NOT_HANDLED;

    // Notify
    if (result.success()) {
        if (fileName.length())
        {
            OSG_NOTICE << "osgDB::ReaderWriterIV::readNode() "
                      << "File " << fileName
                      << " loaded successfully." << std::endl;
        }
        else
        {
            OSG_NOTICE << "osgDB::ReaderWriterIV::readNode() "
                      << "Stream loaded successfully." << std::endl;
        }
    } else {
        if (fileName.length())
        {
            OSG_WARN << "osgDB::ReaderWriterIV::readNode() "
                      << "Failed to load file " << fileName
                      << "." << std::endl;
        }
        else
        {
            OSG_WARN << "osgDB::ReaderWriterIV::readNode() "
                  << "Failed to load stream." << std::endl;
        }
    }

    return result;
}