geom/src/GEOMImpl/GEOMImpl_IInsertOperations.cxx

// Copyright (C) 2007-2014  CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//

#include <Standard_Stream.hxx>

#include <GEOMImpl_IInsertOperations.hxx>

#include <GEOMImpl_CopyDriver.hxx>
#include <GEOMImpl_ExportDriver.hxx>
#include <GEOMImpl_ImportDriver.hxx>
#include <GEOMImpl_ICopy.hxx>
#include <GEOMImpl_IImportExport.hxx>
#include <GEOMImpl_Types.hxx>
#include "GEOMImpl_IShapesOperations.hxx"
#include "GEOMImpl_IGroupOperations.hxx"
#include "GEOMImpl_IFieldOperations.hxx"
#include "GEOMImpl_XAODriver.hxx"
#include "GEOMImpl_IImportExportXAO.hxx"

#include <GEOM_Function.hxx>
#include <GEOM_PythonDump.hxx>
#include "GEOM_ISubShape.hxx"

#include <XAO_Xao.hxx>
#include <XAO_Geometry.hxx>
#include <XAO_BrepGeometry.hxx>
#include <XAO_Group.hxx>
#include <XAO_Field.hxx>
#include <XAO_XaoUtils.hxx>
#include <XAO_BooleanField.hxx>
#include <XAO_IntegerField.hxx>
#include <XAO_DoubleField.hxx>
#include <XAO_StringField.hxx>
#include <XAO_BooleanStep.hxx>
#include <XAO_IntegerStep.hxx>
#include <XAO_DoubleStep.hxx>
#include <XAO_StringStep.hxx>

#include <Basics_OCCTVersion.hxx>

#include "utilities.h"
#include <OpUtil.hxx>
#include <Utils_ExceptHandlers.hxx>

#include <TFunction_DriverTable.hxx>
#include <TFunction_Driver.hxx>
#include <TFunction_Logbook.hxx>
#include <TDF_ChildIDIterator.hxx>
#include <TDF_Tool.hxx>
#include <TDataStd_Integer.hxx>
#include <TNaming_NamedShape.hxx>
#include <TDataStd_Comment.hxx>
#include <TopTools_IndexedMapOfShape.hxx>
#include <TopExp.hxx>

#include <TopoDS.hxx>
#include <TopoDS_Vertex.hxx>
#include <BRep_Builder.hxx>
#include <BRep_Tool.hxx>
#include <BRepTools.hxx>
#include <gp_Pnt.hxx>

#if OCC_VERSION_LARGE > 0x06040000 // Porting to OCCT6.5.1
#include <TColStd_HArray1OfByte.hxx>
#include <TColStd_HArray1OfReal.hxx>
#else
#include <TDataStd_HArray1OfByte.hxx>
#endif

#include <Standard_Failure.hxx>
#include <Standard_ErrorHandler.hxx> // CAREFUL ! position of this file is critic : see Lucien PIGNOLONI / OCC

/**
 * This function returns the input format name from the original format name.
 */
static TCollection_AsciiString GetImportFormatName
        (const TCollection_AsciiString& theFormatName)
{
  return theFormatName.Token("_");
}

//=============================================================================
/*!
 *  constructor
 */
//=============================================================================
GEOMImpl_IInsertOperations::GEOMImpl_IInsertOperations(GEOM_Engine* theEngine, int theDocID)
: GEOM_IOperations(theEngine, theDocID)
{
  MESSAGE("GEOMImpl_IInsertOperations::GEOMImpl_IInsertOperations");
  myShapesOperations = new GEOMImpl_IShapesOperations(GetEngine(), GetDocID());
  myGroupOperations = new GEOMImpl_IGroupOperations(GetEngine(), GetDocID());
  myFieldOperations = new GEOMImpl_IFieldOperations(GetEngine(), GetDocID());
}

//=============================================================================
/*!
 *  destructor
 */
//=============================================================================
GEOMImpl_IInsertOperations::~GEOMImpl_IInsertOperations()
{
  MESSAGE("GEOMImpl_IInsertOperations::~GEOMImpl_IInsertOperations");
  delete myShapesOperations;
  delete myGroupOperations;
  delete myFieldOperations;
}

//=============================================================================
/*!
 *  MakeCopy
 */
//=============================================================================
Handle(GEOM_Object) GEOMImpl_IInsertOperations::MakeCopy (Handle(GEOM_Object) theOriginal)
{
  SetErrorCode(KO);

  if (theOriginal.IsNull()) return NULL;

  //Add a new Copy object
  Handle(GEOM_Object) aCopy = GetEngine()->AddObject(GetDocID(), GEOM_COPY);

  //Add a Copy function for creation a copy object
  Handle(GEOM_Function) aFunction = aCopy->AddFunction(GEOMImpl_CopyDriver::GetID(), COPY_WITH_REF);

  //Check if the function is set correctly
  if(aFunction->GetDriverGUID() != GEOMImpl_CopyDriver::GetID()) return NULL;

  GEOMImpl_ICopy aCI(aFunction);

  Handle(GEOM_Function) aRefFunction = theOriginal->GetLastFunction();
  if (aRefFunction.IsNull()) return NULL;

  aCI.SetOriginal(aRefFunction);

  //Compute the Copy value
  try {
#if OCC_VERSION_LARGE > 0x06010000
    OCC_CATCH_SIGNALS;
#endif
    if (!GetSolver()->ComputeFunction(aFunction)) {
      SetErrorCode("Copy driver failed");
      return NULL;
    }
  }
  catch (Standard_Failure) {
    Handle(Standard_Failure) aFail = Standard_Failure::Caught();
    SetErrorCode(aFail->GetMessageString());
    return NULL;
  }

  //Make a Python command
  GEOM::TPythonDump(aFunction) << aCopy << " = geompy.MakeCopy(" << theOriginal << ")";

  SetErrorCode(OK);
  return aCopy;
}

//=============================================================================
/*!
 *  Export
 */
//=============================================================================
void GEOMImpl_IInsertOperations::Export
                     (const Handle(GEOM_Object)      theOriginal,
                      const TCollection_AsciiString& theFileName,
                      const TCollection_AsciiString& theFormatName)
{
  SetErrorCode(KO);

  if (theOriginal.IsNull()) return;

  Handle(GEOM_Function) aRefFunction = theOriginal->GetLastFunction();
  if (aRefFunction.IsNull()) return;  //There is no function which creates an object to be exported

  //Add a new result object
  Handle(GEOM_Object) result = GetEngine()->AddObject(GetDocID(), GEOM_IMPORT);

  //Add an Export function
  Handle(GEOM_Function) aFunction = result->AddFunction(GEOMImpl_ExportDriver::GetID(), EXPORT_SHAPE);
  if (aFunction.IsNull()) return;

  //Check if the function is set correctly
  if (aFunction->GetDriverGUID() != GEOMImpl_ExportDriver::GetID()) return;

  Handle(TCollection_HAsciiString) aHLibName;
  if (!IsSupported(Standard_False, theFormatName, aHLibName)) {
    return;
  }
  TCollection_AsciiString aLibName = aHLibName->String();

  //Set parameters
  GEOMImpl_IImportExport aCI (aFunction);
  aCI.SetOriginal(aRefFunction);
  aCI.SetFileName(theFileName);
  aCI.SetFormatName(theFormatName);
  aCI.SetPluginName(aLibName);

  //Perform the Export
  try {
#if OCC_VERSION_LARGE > 0x06010000
    OCC_CATCH_SIGNALS;
#endif
    if (!GetSolver()->ComputeFunction(aFunction)) {
      SetErrorCode("Not enough space on disk, or you haven't permissions to write this directory");
      return;
    }
  }
  catch (Standard_Failure) {
    Handle(Standard_Failure) aFail = Standard_Failure::Caught();
    SetErrorCode(aFail->GetMessageString());
    return;
  }

  //Make a Python command
  GEOM::TPythonDump(aFunction) << "geompy.Export(" << theOriginal << ", \""
    << theFileName.ToCString() << "\", \"" << theFormatName.ToCString() << "\")";

  SetErrorCode(OK);
}

//=============================================================================
/*!
 *  Import
 */
//=============================================================================
Handle(TColStd_HSequenceOfTransient) GEOMImpl_IInsertOperations::Import
                                 (const TCollection_AsciiString& theFileName,
                                  const TCollection_AsciiString& theFormatName)
{
  SetErrorCode(KO);

  if (theFileName.IsEmpty() || theFormatName.IsEmpty()) return NULL;

  //Add a new result object
  Handle(GEOM_Object) anImported = GetEngine()->AddObject(GetDocID(), GEOM_IMPORT);

  //Add an Import function
  Handle(GEOM_Function) aFunction =
    anImported->AddFunction(GEOMImpl_ImportDriver::GetID(), IMPORT_SHAPE);

  if (aFunction.IsNull()) return NULL;

  //Check if the function is set correctly
  if (aFunction->GetDriverGUID() != GEOMImpl_ImportDriver::GetID()) return NULL;

  Handle(TCollection_HAsciiString) aHLibName;
  if (!IsSupported
          (Standard_True, GetImportFormatName(theFormatName), aHLibName)) {
    return NULL;
  }
  TCollection_AsciiString aLibName = aHLibName->String();

  //Set parameters
  GEOMImpl_IImportExport aCI (aFunction);
  aCI.SetFileName(theFileName);
  aCI.SetFormatName(theFormatName);
  aCI.SetPluginName(aLibName);

  //Perform the Import
  Handle(TColStd_HSequenceOfTransient) aSeq = new TColStd_HSequenceOfTransient;

  try {
#if OCC_VERSION_LARGE > 0x06010000
    OCC_CATCH_SIGNALS;
#endif
    if (!GetSolver()->ComputeFunction(aFunction)) {
      SetErrorCode("Import driver failed");
      return NULL;
    }

    aSeq->Append(anImported);

    // Greate material groups.
    MakeMaterialGroups(anImported, aSeq);
  }
  catch (Standard_Failure) {
    Handle(Standard_Failure) aFail = Standard_Failure::Caught();
    SetErrorCode(aFail->GetMessageString());
    return NULL;
  }

  //Make a Python command
  if (theFormatName != "IGES_UNIT") {
    GEOM::TPythonDump pd (aFunction);
    if (theFormatName == "BREP")
      pd << aSeq << " = geompy.ImportBREP(\"" << theFileName.ToCString() << "\")";
    else if (theFormatName == "IGES")
      pd << aSeq << " = geompy.ImportIGES(\"" << theFileName.ToCString() << "\")";
    else if (theFormatName == "IGES_SCALE")
      pd << aSeq << " = geompy.ImportIGES(\"" << theFileName.ToCString() << "\", True)";
    else if (theFormatName == "STEP")
      pd << aSeq << " = geompy.ImportSTEP(\"" << theFileName.ToCString() << "\")";
    else if (theFormatName == "STEP_SCALE")
      pd << aSeq << " = geompy.ImportSTEP(\"" << theFileName.ToCString() << "\", True)";
    else {
      pd << aSeq << " = geompy.ImportFile(\""
         << theFileName.ToCString() << "\", \"" << theFormatName.ToCString() << "\")";
    }
  }

  SetErrorCode(OK);

  // OLD CODE: begin
  if (theFormatName == "IGES_UNIT") {
    TopoDS_Shape S = aFunction->GetValue();
    TopoDS_Vertex V = TopoDS::Vertex(S);
    gp_Pnt P = BRep_Tool::Pnt(V);
    double scale = P.X();
    TCollection_AsciiString aUnitName = "UNIT_M";
    if (fabs(scale-0.01) < 1.e-6)
      aUnitName = "UNIT_CM";
    else if (fabs(scale-0.001) < 1.e-6)
      aUnitName = "UNIT_MM";
    //cout<<"IIO: aUnitName = "<<aUnitName.ToCString()<<endl;
    SetErrorCode(aUnitName);
  }
  // OLD CODE: end

  return aSeq;
}

//=============================================================================
/*!
 *  ReadValue
 */
//=============================================================================
TCollection_AsciiString GEOMImpl_IInsertOperations::ReadValue
                                 (const TCollection_AsciiString& theFileName,
                                  const TCollection_AsciiString& theFormatName,
                                  const TCollection_AsciiString& theParameterName)
{
  SetErrorCode(KO);

  TCollection_AsciiString aValue, anError;

  if (theFileName.IsEmpty() || theFormatName.IsEmpty() || theParameterName.IsEmpty()) return aValue;

  Handle(TCollection_HAsciiString) aHLibName;
  if (!IsSupported
          (Standard_True, GetImportFormatName(theFormatName), aHLibName)) {
    return aValue;
  }
  TCollection_AsciiString aLibName = aHLibName->String();

  aValue = GEOMImpl_ImportDriver::ReadValue(theFileName, aLibName, theParameterName, anError);
  if (anError.IsEmpty())
    SetErrorCode(OK);
  else
    SetErrorCode(anError.ToCString());

  return aValue;
}

//=============================================================================
/*!
 *  ImportTranslators
 */
//=============================================================================
Standard_Boolean GEOMImpl_IInsertOperations::ImportTranslators
                     (Handle(TColStd_HSequenceOfAsciiString)& theFormats,
                      Handle(TColStd_HSequenceOfAsciiString)& thePatterns)
{
  if (theFormats.IsNull())
    theFormats = new TColStd_HSequenceOfAsciiString;
  else
    theFormats->Clear();

  if (thePatterns.IsNull())
    thePatterns = new TColStd_HSequenceOfAsciiString;
  else
    thePatterns->Clear();

  if (!InitResMgr()) return Standard_False;

  // Read Import formats from directories
  Handle(Resource_Manager) aResMgr;
  Handle(TColStd_HSequenceOfAsciiString) aFormatsToAdd;
  for(int index = 0; index < myResMgrList.size(); index++) {
    int anOldLen = theFormats->Length();
    aResMgr = myResMgrList.at(index);
    if (aResMgr->Find("Import")) {
      TCollection_AsciiString aFormats (aResMgr->Value("Import"));
      TCollection_AsciiString aToken = aFormats.Token("| \t", 1);
      for (int i = 1; !aToken.IsEmpty(); aToken = aFormats.Token("| \t", ++i)) {
        int aLenFormats = theFormats->Length();
        bool isFound = false;
        for(int aInd=1;aInd<=aLenFormats;aInd++){
          if( theFormats->Value(aInd) == aToken ){
            isFound = true;
            break;
          }
        }
        if(!isFound)
          theFormats->Append(aToken);
      }
    }

    // Read Patterns for each supported format
    for (int j = anOldLen+1; j <= theFormats->Length(); j++) {
      TCollection_AsciiString aKey, aPattern;
      aKey = theFormats->Value(j) + ".ImportPattern";
      if (aResMgr->Find(aKey.ToCString()))
        aPattern = aResMgr->Value(aKey.ToCString());
      else {
        aKey = theFormats->Value(j) + ".Pattern";
        if (aResMgr->Find(aKey.ToCString()))
          aPattern = aResMgr->Value(aKey.ToCString());
        else {
          aPattern = theFormats->Value(j);
          aPattern += " Files ( *.* )";
        }
      }
      thePatterns->Append(aPattern);
    }
  }

  return (!theFormats->IsEmpty());
}

//=============================================================================
/*!
 *  ExportTranslators
 */
//=============================================================================
Standard_Boolean GEOMImpl_IInsertOperations::ExportTranslators
                     (Handle(TColStd_HSequenceOfAsciiString)& theFormats,
                      Handle(TColStd_HSequenceOfAsciiString)& thePatterns)
{
  if (theFormats.IsNull())
    theFormats = new TColStd_HSequenceOfAsciiString;
  else
    theFormats->Clear();

  if (thePatterns.IsNull())
    thePatterns = new TColStd_HSequenceOfAsciiString;
  else
    thePatterns->Clear();

  if (!InitResMgr()) return Standard_False;

  // Read Export formats list from directories
  Handle(Resource_Manager) aResMgr;
  for(int index=0; index < myResMgrList.size(); index++) {
    int anOldLen = theFormats->Length();
    aResMgr = myResMgrList.at(index);
    if (aResMgr->Find("Export")) {
      TCollection_AsciiString aFormats (aResMgr->Value("Export"));
      TCollection_AsciiString aToken = aFormats.Token("| \t", 1);
      for (int i = 1; !aToken.IsEmpty(); aToken = aFormats.Token("| \t", ++i)) {
        int aLenFormats = theFormats->Length();
        bool isFound = false;
        for(int aInd=1;aInd<=aLenFormats;aInd++){
          if( theFormats->Value(aInd) == aToken){
            isFound = true;
            break;
          }
        }
        if(!isFound)
          theFormats->Append(aToken);
      }
    }

    // Read Patterns for each supported format
    for (int j = anOldLen+1; j <= theFormats->Length(); j++) {
      TCollection_AsciiString aKey, aPattern;
      aKey = theFormats->Value(j) + ".ExportPattern";
      if (aResMgr->Find(aKey.ToCString()))
        aPattern = aResMgr->Value(aKey.ToCString());
      else {
        aKey = theFormats->Value(j) + ".Pattern";
        if (aResMgr->Find(aKey.ToCString()))
          aPattern = aResMgr->Value(aKey.ToCString());
        else {
          aPattern = theFormats->Value(j);
          aPattern += " Files ( *.* )";
        }
      }
      thePatterns->Append(aPattern);
    }
  }

  return (!theFormats->IsEmpty());
}

//=============================================================================
/*!
 *  IsSupported
 */
//=============================================================================
Standard_Boolean GEOMImpl_IInsertOperations::IsSupported
                            (const Standard_Boolean isImport,
                             const TCollection_AsciiString& theFormat,
                             Handle(TCollection_HAsciiString)& theLibName)
{
  if (!InitResMgr()) return Standard_False;

  // Import/Export mode
  TCollection_AsciiString aMode;
  //Standard_CString aMode;
  if (isImport) aMode = "Import";
  else aMode = "Export";

  // Read supported formats for the certain mode from user directory
  Handle(Resource_Manager) aResMgr;
  for(int index=0; index < myResMgrList.size(); index++) {
    aResMgr = myResMgrList.at(index);
    if (aResMgr->Find(aMode.ToCString())) {
      TCollection_AsciiString aFormats (aResMgr->Value(aMode.ToCString()));
      if (aFormats.Search(theFormat) > -1) {
        // Read library name for the supported format
        TCollection_AsciiString aKey (theFormat);
        aKey += ".";
        aKey += aMode;
        if (aResMgr->Find(aKey.ToCString())) {
          TCollection_AsciiString aLibName (aResMgr->Value(aKey.ToCString()));
  #ifndef WIN32
	  if ( aLibName.Length() > 3 && aLibName.SubString(1,3) != "lib" )
	    aLibName.Prepend("lib");
          aLibName += ".so";
  #else
          aLibName += ".dll";
  #endif
          theLibName = new TCollection_HAsciiString (aLibName);
          return Standard_True;
        }
      }
    }
  }
  
  return Standard_False;
}

//=============================================================================
/*!
 *  InitResMgr
 */
//=============================================================================
Standard_Boolean GEOMImpl_IInsertOperations::InitResMgr()
{
  bool isResourceFound = false;
  TCollection_AsciiString aNull;
  
  myResMgrList.clear();

  // Initialize the GEOM Resource Manager
  TCollection_AsciiString aResDir;
  aResDir = getenv("GEOM_ROOT_DIR");
#ifdef WIN32
  aResDir += "\\share\\salome\\resources\\geom";
#else
  aResDir += "/share/salome/resources/geom";
#endif
  Handle(Resource_Manager) aGeomResMgr = new Resource_Manager ("ImportExport", aResDir, aNull, Standard_False);
  if ( aGeomResMgr->Find("Import") || aGeomResMgr->Find("Export") ) {
    myResMgrList.push_back( aGeomResMgr );
    isResourceFound = true;
  }

  // Initialize the user's Resource Manager
  TCollection_AsciiString aResDirsStr;
  aResDirsStr = getenv("GEOM_ENGINE_RESOURCES_DIR");
  if ( !aResDirsStr.IsEmpty() )
  {
    std::string aSep = ":";
#ifdef WIN32
    aSep = ";";
#endif
    aResDir = aResDirsStr.Token(aSep.c_str(), 1);
    for (int i = 1; !aResDir.IsEmpty(); aResDir = aResDirsStr.Token(aSep.c_str(), ++i)) {
      Handle(Resource_Manager) anUserResMgr = new Resource_Manager ("ImportExport", aNull, aResDir, Standard_False);
      if (anUserResMgr->Find("Import") || anUserResMgr->Find("Export")) {
        myResMgrList.push_back( anUserResMgr );
        isResourceFound = true;
      }
    }
  }
  else
  {
    aResDir = getenv("HOME");
#ifdef WIN32
    aResDir += "\\.config\\salome";
#else
    aResDir += "/.config/salome";
#endif
    Handle(Resource_Manager) anUserResMgr = new Resource_Manager ("ImportExport", aNull, aResDir, Standard_False);
    if (anUserResMgr->Find("Import") || anUserResMgr->Find("Export")) {
      myResMgrList.push_back( anUserResMgr );
      isResourceFound = true;
    }
  }
  return isResourceFound;
}

//=============================================================================
/*!
 *  RestoreShape
 */
//=============================================================================
Handle(GEOM_Object) GEOMImpl_IInsertOperations::RestoreShape (std::istringstream& theStream)
{
  SetErrorCode(KO);

  //Add a new result object
  Handle(GEOM_Object) result = GetEngine()->AddObject(GetDocID(), GEOM_COPY);

  //Add a Copy function
  Handle(GEOM_Function) aFunction = result->AddFunction(GEOMImpl_CopyDriver::GetID(), COPY_WITHOUT_REF);
  if (aFunction.IsNull()) return NULL;

  //Check if the function is set correctly
  if (aFunction->GetDriverGUID() != GEOMImpl_CopyDriver::GetID()) return NULL;

  //Read a shape from the stream
  TopoDS_Shape aShape;
  BRep_Builder B;
  BRepTools::Read(aShape, theStream, B);
  if (aShape.IsNull()) {
    SetErrorCode("RestoreShape error: BREP reading failed");
  }

  //Set function value
  aFunction->SetValue(aShape);

  //Special dump to avoid restored shapes publication.
  //See correcponding code in GEOM_Engine.cxx (method ProcessFunction)
  //GEOM::TPythonDump(aFunction) << "#";

  GEOM::TPythonDump(aFunction) << result
    << " = geompy.RestoreShape(\"\") # the shape string has not been dump for performance reason";

  SetErrorCode(OK);

  return result;
}

int GEOMImpl_IInsertOperations::LoadTexture(const TCollection_AsciiString& theTextureFile)
{
  SetErrorCode(KO);

  if (theTextureFile.IsEmpty()) return 0;

#if OCC_VERSION_LARGE > 0x06040000 // Porting to OCCT6.5.1
  Handle(TColStd_HArray1OfByte) aTexture;
#else
  Handle(TDataStd_HArray1OfByte) aTexture;
#endif

  FILE* fp = fopen(theTextureFile.ToCString(), "r");
  if (!fp) return 0;

  std::list<std::string> lines;
  char buffer[4096];
  int maxlen = 0;
  while (!feof(fp)) {
    if ((fgets(buffer, 4096, fp)) == NULL) break;
    int aLen = strlen(buffer);
    if (buffer[aLen-1] == '\n') buffer[aLen-1] = '\0';
    lines.push_back(buffer);
    maxlen = std::max(maxlen, (int)strlen(buffer));
  }

  fclose(fp);

  int lenbytes = maxlen/8;
  if (maxlen%8) lenbytes++;

  if (lenbytes == 0 || lines.empty())
    return 0;

  std::list<unsigned char> bytedata;
  std::list<std::string>::const_iterator it;
  for (it = lines.begin(); it != lines.end(); ++it) {
    std::string line = *it;
    int lenline = (line.size()/8 + (line.size()%8 ? 1 : 0)) * 8;
    for (int i = 0; i < lenline/8; i++) {
      unsigned char byte = 0;
      for (int j = 0; j < 8; j++)
        byte = (byte << 1) + ( i*8+j < line.size() && line[i*8+j] != '0' ? 1 : 0 );
      bytedata.push_back(byte);
    }
    for (int i = lenline/8; i < lenbytes; i++)
      bytedata.push_back((unsigned char)0);
  }

  if (bytedata.empty() || bytedata.size() != lines.size()*lenbytes)
    return 0;

#if OCC_VERSION_LARGE > 0x06040000 // Porting to OCCT6.5.1
  aTexture = new TColStd_HArray1OfByte (1, lines.size()*lenbytes);
#else
  aTexture = new TDataStd_HArray1OfByte (1, lines.size()*lenbytes);
#endif

  std::list<unsigned char>::iterator bdit;
  int i;
  for (i = 1, bdit = bytedata.begin(); bdit != bytedata.end(); ++bdit, ++i)
    aTexture->SetValue(i, (Standard_Byte)(*bdit));

  int aTextureId = GetEngine()->addTexture(GetDocID(), lenbytes*8, lines.size(), aTexture, theTextureFile);
  if (aTextureId > 0) SetErrorCode(OK);
  return aTextureId;
}
  
int GEOMImpl_IInsertOperations::AddTexture(int theWidth, int theHeight, 
#if OCC_VERSION_LARGE > 0x06040000 // Porting to OCCT6.5.1
                                           const Handle(TColStd_HArray1OfByte)& theTexture)
#else
                                           const Handle(TDataStd_HArray1OfByte)& theTexture)
#endif
{
  SetErrorCode(KO);
  int aTextureId = GetEngine()->addTexture(GetDocID(), theWidth, theHeight, theTexture);
  if (aTextureId > 0) SetErrorCode(OK);
  return aTextureId;
}

#if OCC_VERSION_LARGE > 0x06040000 // Porting to OCCT6.5.1
Handle(TColStd_HArray1OfByte) GEOMImpl_IInsertOperations::GetTexture(int theTextureId,
#else
Handle(TDataStd_HArray1OfByte) GEOMImpl_IInsertOperations::GetTexture(int theTextureId,
#endif
                                                                      int& theWidth, int& theHeight)
{
  SetErrorCode(KO);
  
#if OCC_VERSION_LARGE > 0x06040000 // Porting to OCCT6.5.1
  Handle(TColStd_HArray1OfByte) aTexture;
#else
  Handle(TDataStd_HArray1OfByte) aTexture;
#endif

  theWidth = theHeight = 0;
  TCollection_AsciiString aFileName;

  if (theTextureId <= 0)
    return aTexture;

  aTexture = GetEngine()->getTexture(GetDocID(), theTextureId, theWidth, theHeight, aFileName);

  if (theWidth > 0 && theHeight > 0 && aTexture->Length() > 0) SetErrorCode(OK);

  return aTexture;
}

std::list<int> GEOMImpl_IInsertOperations::GetAllTextures()
{
  SetErrorCode(KO);
  std::list<int> id_list = GetEngine()->getAllTextures(GetDocID());
  SetErrorCode(OK);
  return id_list;
}

TopAbs_ShapeEnum getGroupDimension(XAO::Group* group)
{
  XAO::Dimension dim = group->getDimension();
  TopAbs_ShapeEnum rdim;
  switch ( dim )
  {
  case XAO::VERTEX:
    rdim = TopAbs_VERTEX; break;
  case XAO::EDGE:
    rdim = TopAbs_EDGE; break;
  case XAO::FACE:
    rdim = TopAbs_FACE; break;
  case XAO::SOLID:
    rdim = TopAbs_SOLID; break;
  default:
    rdim = TopAbs_COMPOUND; break;
  }
  return rdim;
}

XAO::Dimension shapeEnumToDimension(const TopAbs_ShapeEnum& shape)
{
  XAO::Dimension dim;
  switch( shape ) {
  case TopAbs_VERTEX:
    dim = XAO::VERTEX; break;
  case TopAbs_EDGE:
    dim = XAO::EDGE; break;
  case TopAbs_FACE:
    dim = XAO::FACE; break;
  case TopAbs_SOLID:
    dim = XAO::SOLID; break;
  default:
    throw SALOME_Exception("Bad type"); // TODO
  }
  return dim;
}

void GEOMImpl_IInsertOperations::exportGroups(std::list<Handle(GEOM_Object)> groupList,
                                              XAO::Xao* xaoObject,
                                              XAO::BrepGeometry* geometry)
{
  // add the groups
  std::list<Handle(GEOM_Object)>::iterator groupIterator = groupList.begin();
  while (groupIterator != groupList.end())
  {
    Handle(GEOM_Object) currGroup = (*groupIterator++);
    Handle(TColStd_HArray1OfInteger) groupIds = myGroupOperations->GetObjects(currGroup);
    
    TopAbs_ShapeEnum shapeGroup = myGroupOperations->GetType(currGroup);
    XAO::Dimension dim = shapeEnumToDimension(shapeGroup);
    XAO::Group* group = xaoObject->addGroup(dim, currGroup->GetName().ToCString());
    
    switch (shapeGroup)
    {
    case TopAbs_VERTEX:
      for (int i = 1; i <= groupIds->Length(); i++)
      {
        std::string ref = XAO::XaoUtils::intToString(groupIds->Value(i));
        int index = geometry->getVertexIndexByReference(ref);
        group->add(index);
      }
      break;
    case TopAbs_EDGE:
      for (int i = 1; i <= groupIds->Length(); i++)
      {
        std::string ref = XAO::XaoUtils::intToString(groupIds->Value(i));
        int index = geometry->getEdgeIndexByReference(ref);
        group->add(index);
      }
      break;
    case TopAbs_FACE:
      for (int i = 1; i <= groupIds->Length(); i++)
      {
        std::string ref = XAO::XaoUtils::intToString(groupIds->Value(i));
        int index = geometry->getFaceIndexByReference(ref);
        group->add(index);
      }
      break;
    case TopAbs_SOLID:
      for (int i = 1; i <= groupIds->Length(); i++)
      {
        std::string ref = XAO::XaoUtils::intToString(groupIds->Value(i));
        int index = geometry->getSolidIndexByReference(ref);
        group->add(index);
      }
      break;
    }
  }
}

void GEOMImpl_IInsertOperations::exportFields(std::list<Handle(GEOM_Field)> fieldList,
                                              XAO::Xao* xaoObject,
                                              XAO::BrepGeometry* geometry)
{
    std::list<Handle(GEOM_Field)>::iterator fieldIterator = fieldList.begin();
    while (fieldIterator != fieldList.end())
    {
        Handle(GEOM_Field) currField = (*fieldIterator++);

        int fdim = currField->GetDimension();
        int ftype = currField->GetDataType();
        int nbComponents = currField->GetNbComponents();
        std::string name = currField->GetName().ToCString();

        XAO::Field* field = xaoObject->addField((XAO::Type)ftype, (XAO::Dimension)fdim, nbComponents, name);

        Handle(TColStd_HArray1OfExtendedString) components = currField->GetComponents();
        for (int i = components->Lower(), j = 0; i <= components->Upper(); ++i, ++j)
        {
            field->setComponentName(j, TCollection_AsciiString(components->Value(i)).ToCString());
        }

        std::list< Handle(GEOM_FieldStep)> steps = currField->GetSteps();
        std::list<Handle(GEOM_FieldStep)>::iterator stepIterator = steps.begin();
        while (stepIterator != steps.end())
        {
            Handle(GEOM_FieldStep) currStep = (*stepIterator++);

            XAO::Step* step = field->addNewStep(currStep->GetID());
            step->setStamp(currStep->GetStamp());

            switch (ftype)
            {
                case 0: // bool
                {
                    XAO::BooleanStep* bs = (XAO::BooleanStep*)step;
                    Handle(TColStd_HArray1OfInteger) bvalues = currStep->GetIntValues();
                    std::vector<bool> bv;
                    bv.reserve(bvalues->Upper());
                    for ( int i = bvalues->Lower(), nb = bvalues->Upper(); i <= nb; ++i )
                    {
                        bv.push_back(bvalues->Value(i) != 0);
                    }
                    bs->setValues(bv);
                    break;
                }
                case 1: // integer
                {
                    XAO::IntegerStep* is = (XAO::IntegerStep*)step;
                    Handle(TColStd_HArray1OfInteger) ivalues = currStep->GetIntValues();
                    std::vector<int> iv;
                    iv.reserve(ivalues->Upper());
                    for ( int i = ivalues->Lower(), nb = ivalues->Upper(); i <= nb; ++i )
                    {
                        iv.push_back(ivalues->Value(i));
                    }
                    is->setValues(iv);
                    break;
                }
                case 2: // double
                {
                    XAO::DoubleStep* ds = (XAO::DoubleStep*)step;
                    Handle(TColStd_HArray1OfReal) dvalues = currStep->GetDoubleValues();
                    std::vector<double> dv;
                    dv.reserve(dvalues->Upper());
                    for ( int i = dvalues->Lower(), nb = dvalues->Upper(); i <= nb; ++i )
                    {
                        dv.push_back(dvalues->Value(i));
                    }
                    ds->setValues(dv);
                    break;
                }
                case 3: // string
                {
                    XAO::StringStep* ss = (XAO::StringStep*)step;
                    Handle(TColStd_HArray1OfExtendedString) svalues = currStep->GetStringValues();
                    std::vector<std::string> sv;
                    sv.reserve(svalues->Upper());
                    for ( int i = svalues->Lower(), nb = svalues->Upper(); i <= nb; ++i )
                    {
                        sv.push_back(TCollection_AsciiString(svalues->Value(i)).ToCString());
                    }
                    ss->setValues(sv);
                    break;
                }
            }
        }
    }
}

void GEOMImpl_IInsertOperations::exportSubshapes(const Handle(GEOM_Object)& shape, XAO::BrepGeometry* geometry)
{
  Handle(TColStd_HSequenceOfTransient) subObjects = myShapesOperations->GetExistingSubObjects(shape, false);
  int nbSubObjects = subObjects->Length();
  // set the names of the sub shapes
  for (int i = 1; i <= nbSubObjects; i++)
  {
    Handle(Standard_Transient) transientSubObject = subObjects->Value(i);
    if (transientSubObject.IsNull())
      continue;
    
    Handle(GEOM_Object) subObject = Handle(GEOM_Object)::DownCast(transientSubObject);
    if (subObject->GetType() != GEOM_GROUP)
    {
      int subIndex = myShapesOperations->GetSubShapeIndex(shape, subObject);
      switch (subObject->GetValue().ShapeType())
      {
      case TopAbs_VERTEX:
        geometry->changeVertexName(subIndex, subObject->GetName().ToCString());
        break;
      case TopAbs_EDGE:
        geometry->changeEdgeName(subIndex, subObject->GetName().ToCString());
        break;
      case TopAbs_FACE:
        geometry->changeFaceName(subIndex, subObject->GetName().ToCString());
        break;
      case TopAbs_SOLID:
        geometry->changeSolidName(subIndex, subObject->GetName().ToCString());
        break;
      }
    }
  }
}

//=============================================================================
/*!
 *  Export a shape to XAO format
 *  \param shape The shape to export
 *  \param groups The list of groups to export
 *  \param fields The list of fields to export
 *  \param fileName The name of the file to exported
 *  \return boolean indicating if export was succeful.
 */
//=============================================================================
bool GEOMImpl_IInsertOperations::ExportXAO(Handle(GEOM_Object) shape,
                                           std::list<Handle(GEOM_Object)> groupList,
                                           std::list<Handle(GEOM_Field)> fieldList,
                                           const char* author,
                                           const char* fileName)
{
  SetErrorCode(KO);

  if (shape.IsNull()) return false;
  
  // add a new shape function with parameters
  Handle(GEOM_Function) lastFunction = shape->GetLastFunction();
  if (lastFunction.IsNull()) return false;
  
  // add a new result object
  Handle(GEOM_Object) result = GetEngine()->AddObject(GetDocID(), GEOM_IMPORT);
  
  // add an Export function
  Handle(GEOM_Function) exportFunction = result->AddFunction(GEOMImpl_XAODriver::GetID(), IMPORTEXPORT_EXPORTXAO);
  if (exportFunction.IsNull()) return false;
  if (exportFunction->GetDriverGUID() != GEOMImpl_XAODriver::GetID()) return false;
  
  // create the XAO object
  XAO::Xao* xaoObject = new XAO::Xao();
  xaoObject->setAuthor(author);
  
  // add the geometry
  XAO::BrepGeometry* geometry = (XAO::BrepGeometry*)XAO::Geometry::createGeometry(XAO::BREP);
  TopoDS_Shape topoShape = shape->GetValue();
  exportFunction->SetValue(topoShape);
  XAO::BrepGeometry* brep = (XAO::BrepGeometry*)geometry;
  brep->setTopoDS_Shape(topoShape);
  
  geometry->setName(shape->GetName().ToCString());
  exportSubshapes(shape, geometry);
  xaoObject->setGeometry(geometry);
  
  exportGroups(groupList, xaoObject, geometry);
  exportFields(fieldList, xaoObject, geometry);
  
  // export the XAO to the file
  xaoObject->exportXAO(fileName);
  
  // make a Python command
  GEOM::TPythonDump pd(exportFunction);
  pd << "exported = geompy.ExportXAO(" << shape;
  
  // list of groups
  pd << ", [";
  if (groupList.size() > 0)
  {
    std::list<Handle(GEOM_Object)>::iterator itGroup = groupList.begin();
    pd << (*itGroup++);
    while (itGroup != groupList.end())
    {
      pd << ", " << (*itGroup++);
    }
  }

  // list of fields
  pd << "], [";
  if (fieldList.size() > 0)
  {
    std::list<Handle(GEOM_Field)>::iterator itField = fieldList.begin();
    pd << (*itField++);
    while (itField != fieldList.end())
    {
      pd << ", " << (*itField++);
    }
  }
  pd << "], ";
  pd << "\"" << author << "\", \"" << fileName << "\")";
  
  SetErrorCode(OK);
  delete xaoObject;
  
  return true;
}

void GEOMImpl_IInsertOperations::importSubShapes(XAO::Geometry* xaoGeometry,
                                                 Handle(GEOM_Function) function, int shapeType, int dim,
                                                 Handle(TColStd_HSequenceOfTransient)& subShapeList)
{
  Handle(GEOM_Object) subShape;
  Handle(GEOM_Function) aFunction;
  Handle(TColStd_HArray1OfInteger) anArray;
  
  XAO::GeometricElementList::iterator elementIterator = xaoGeometry->begin((XAO::Dimension)dim);
  for (; elementIterator != xaoGeometry->end((XAO::Dimension)dim); elementIterator++)
  {
    XAO::GeometricElement element = elementIterator->second;
    if (!element.hasName())
      continue;
    
    std::string name = element.getName();
    std::string ref = element.getReference();
    int iref = XAO::XaoUtils::stringToInt(ref);
    
    anArray = new TColStd_HArray1OfInteger(1, 1);
    anArray->SetValue(1, iref);
    
    subShape = GetEngine()->AddObject(GetDocID(), GEOM_SUBSHAPE);
    Handle(GEOM_Function) aFunction = subShape->AddFunction(GEOM_Object::GetSubShapeID(), 1);
    if (aFunction.IsNull())
      return;
    
    subShape->SetName(name.c_str());
    subShape->SetType(shapeType);
    
    GEOM_ISubShape aSSI(aFunction);
    aSSI.SetMainShape(function);
    aSSI.SetIndices(anArray);
    
    //aFunction->SetValue(aValue);
    subShapeList->Append(subShape);
    
    // Put this subshape in the list of sub-shapes of theMainShape
    function->AddSubShapeReference(aFunction);
  }
}

//=============================================================================
/*!
 *  Import a shape from XAO format
 *  \param fileName The name of the file to import
 *  \param shape The imported shape
 *  \param subShapes The list of imported groups
 *  \param groups The list of imported groups
 *  \param fields The list of imported fields
 *  \return boolean indicating if import was succeful.
 */
//=============================================================================
bool GEOMImpl_IInsertOperations::ImportXAO(const char* fileName,
                                           Handle(GEOM_Object)& shape,
                                           Handle(TColStd_HSequenceOfTransient)& subShapes,
                                           Handle(TColStd_HSequenceOfTransient)& groups,
                                           Handle(TColStd_HSequenceOfTransient)& fields)
{
  SetErrorCode(KO);
  
  if (fileName == NULL || groups.IsNull() || fields.IsNull())
    return false;
  
  // Read the XAO
  XAO::Xao* xaoObject = new XAO::Xao();
  try
  {
    xaoObject->importXAO(fileName);
  }
  catch (XAO::XAO_Exception& exc)
  {
    delete xaoObject;
    SetErrorCode(exc.what());
    return false;
  }
  
  XAO::Geometry* xaoGeometry = xaoObject->getGeometry();
  if (xaoGeometry == NULL)
  {
    delete xaoObject;
    SetErrorCode("Cannot import XAO: geometry format not supported.");
    return false;
  }
  
  // create the shape
  shape = GetEngine()->AddObject(GetDocID(), GEOM_IMPORT);
  Handle(GEOM_Function) function = shape->AddFunction(GEOMImpl_XAODriver::GetID(), IMPORTEXPORT_EXPORTXAO);
  if (function.IsNull()) return false;
  if (function->GetDriverGUID() != GEOMImpl_XAODriver::GetID()) return false;
  
  // set the geometry
  if (xaoGeometry->getFormat() == XAO::BREP)
  {
    XAO::BrepGeometry* brep = (XAO::BrepGeometry*)xaoGeometry;
    TopoDS_Shape geomShape = brep->getTopoDS_Shape();
    function->SetValue(geomShape);
    shape->SetName(xaoGeometry->getName().c_str());
  }
  else
  {
    delete xaoObject;
    SetErrorCode("Cannot import XAO: geometry format not supported.");
    return false;
  }
  
  // create sub shapes with names
  importSubShapes(xaoGeometry, function, GEOM_POINT, XAO::VERTEX, subShapes);
  importSubShapes(xaoGeometry, function, GEOM_EDGE, XAO::EDGE, subShapes);
  importSubShapes(xaoGeometry, function, GEOM_FACE, XAO::FACE, subShapes);
  importSubShapes(xaoGeometry, function, GEOM_SOLID, XAO::SOLID, subShapes);
  
  // create groups
  int nbGroups = xaoObject->countGroups();
  for (int i = 0; i < nbGroups; ++i)
  {
    XAO::Group* xaoGroup = xaoObject->getGroup(i);
    
    // build an array with the indexes of the sub shapes
    int nbElt = xaoGroup->count();
    Handle(TColStd_HArray1OfInteger) array = new TColStd_HArray1OfInteger(1, nbElt);
    int j = 0;
    for (std::set<int>::iterator it = xaoGroup->begin(); it != xaoGroup->end(); ++it)
    {
      int index = (*it);
      std::string ref = xaoGeometry->getElementReference(xaoGroup->getDimension(), index);
      array->SetValue(++j, XAO::XaoUtils::stringToInt(ref));
    }
    
    // create the group with the array of sub shapes indexes
    Handle(GEOM_Object) group = GetEngine()->AddSubShape(shape, array);
    group->SetType(GEOM_GROUP);
    group->SetName(xaoGroup->getName().c_str());
    
    // Set a sub-shape type
    TDF_Label freeLabel = group->GetFreeLabel();
    TDataStd_Integer::Set(freeLabel, (Standard_Integer) getGroupDimension(xaoGroup));
    groups->Append(group);
    
    function = group->GetLastFunction();
  }
  
  // create the fields
  int nbFields = xaoObject->countFields();
  for (int i = 0; i < nbFields; ++i)
  {
    XAO::Field* xaoField = xaoObject->getField(i);

    Handle(TColStd_HArray1OfExtendedString) components = new TColStd_HArray1OfExtendedString(0, xaoField->countComponents()-1);
    for (int j = 0; j < xaoField->countComponents(); ++j)
    {
        components->SetValue(j, (TCollection_ExtendedString)xaoField->getComponentName(j).c_str());
    }

    Handle(GEOM_Field) field = myFieldOperations->CreateField(shape,
                 xaoField->getName().c_str(),
                 (int)xaoField->getType(),
                 (int)xaoField->getDimension(),
                 components);

    switch (xaoField->getType())
    {
        case XAO::BOOLEAN:
        {
            XAO::BooleanField* bfield = (XAO::BooleanField*)xaoField;
            for (int j = 0; j < xaoField->countSteps(); ++j)
            {
                XAO::BooleanStep* bstep = bfield->getStep(j);
                Handle(GEOM_FieldStep) step = field->AddStep(bstep->getStep(), bstep->getStamp());

                Handle(TColStd_HArray1OfInteger) values = new TColStd_HArray1OfInteger(0, bstep->countValues()-1);
                std::vector<bool> bvalues = bstep->getValues();
                for (int k = 0; k < bstep->countValues(); ++k)
                {
                    values->SetValue(k, bvalues[k] ? 1 : 0);
                }
                step->SetValues(values);
            }
            break;
        }
        case XAO::INTEGER:
        {
            XAO::IntegerField* ifield = (XAO::IntegerField*)xaoField;
            for (int j = 0; j < xaoField->countSteps(); ++j)
            {
                XAO::IntegerStep* istep = ifield->getStep(j);
                Handle(GEOM_FieldStep) step = field->AddStep(istep->getStep(), istep->getStamp());

                Handle(TColStd_HArray1OfInteger) values = new TColStd_HArray1OfInteger(0, istep->countValues()-1);
                std::vector<int> ivalues = istep->getValues();
                for (int k = 0; k < istep->countValues(); ++k)
                {
                    values->SetValue(k, ivalues[k]);
                }
                step->SetValues(values);
            }
            break;
        }
        case XAO::DOUBLE:
        {
            XAO::DoubleField* dfield = (XAO::DoubleField*)xaoField;
            for (int j = 0; j < xaoField->countSteps(); ++j)
            {
                XAO::DoubleStep* dstep = dfield->getStep(j);
                Handle(GEOM_FieldStep) step = field->AddStep(dstep->getStep(), dstep->getStamp());

                Handle(TColStd_HArray1OfReal) values = new TColStd_HArray1OfReal(0, dstep->countValues()-1);
                std::vector<double> dvalues = dstep->getValues();
                for (int k = 0; k < dstep->countValues(); ++k)
                {
                    values->SetValue(k, dvalues[k]);
                }
                step->SetValues(values);
            }
            break;
        }
        case XAO::STRING:
        {
            XAO::StringField* sfield = (XAO::StringField*)xaoField;
            for (int j = 0; j < xaoField->countSteps(); ++j)
            {
                XAO::StringStep* sstep = sfield->getStep(j);
                Handle(GEOM_FieldStep) step = field->AddStep(sstep->getStep(), sstep->getStamp());

                Handle(TColStd_HArray1OfExtendedString) values = new TColStd_HArray1OfExtendedString(0, sstep->countValues()-1);
                std::vector<std::string> svalues = sstep->getValues();
                for (int k = 0; k < sstep->countValues(); ++k)
                {
                    values->SetValue(k, TCollection_ExtendedString(svalues[k].c_str()));
                }
                step->SetValues(values);
            }
            break;
        }
    }

    fields->Append(field);
  }
  
  // make a Python command
  GEOM::TPythonDump pd(function);
  pd << "(imported, " << shape << ", ";
  
  // list of sub shapes
  pd << "[";
  int nbSubshapes = subShapes->Length();
  if (nbSubshapes > 0)
  {
    for (int i = 1; i <= nbSubshapes; i++)
    {
      Handle(GEOM_Object) obj = Handle(GEOM_Object)::DownCast(subShapes->Value(i));
      pd << obj << ((i < nbSubshapes) ? ", " : "");
    }
  }
  pd << "], [";
  
  // list of groups
  if (nbGroups > 0)
  {
    for (int i = 1; i <= nbGroups; i++)
    {
      Handle(GEOM_Object) obj = Handle(GEOM_Object)::DownCast(groups->Value(i));
      pd << obj << ((i < nbGroups) ? ", " : "");
    }
  }
  
  pd << "], [";
  
  // list of fields
  if (nbFields > 0)
  {
    for (int i = 1; i <= nbFields; i++)
    {
      Handle(GEOM_Field) obj = Handle(GEOM_Field)::DownCast(fields->Value(i));
      pd << obj << ((i < nbFields) ? ", " : "");
    }
  }
  pd << "]";
  pd << ") = geompy.ImportXAO(\"" << fileName << "\")";
  
  delete xaoObject;
  SetErrorCode(OK);
  
  return true;
}

//=============================================================================
/*!
 *  This method creates material groups for an imported object.
 *  \param theObject the imported object.
 */
//=============================================================================
void GEOMImpl_IInsertOperations::MakeMaterialGroups
                        (const Handle(GEOM_Object) &theObject,
                         const Handle(TColStd_HSequenceOfTransient) &theSeq)
{
  TopoDS_Shape aResShape = theObject->GetValue();

  if (aResShape.IsNull() == Standard_False) {
    // Group shapes by material names.
    Handle(GEOM_Function)      aFunction = theObject->GetLastFunction();
    DataMapOfStringListOfShape aMapMaterialShapes;

    // check all named shapes using iterator
    TDF_ChildIDIterator anIt (aFunction->GetNamingEntry(),
        TNaming_NamedShape::GetID(), Standard_True);

    for (; anIt.More(); anIt.Next()) {
      Handle(TNaming_NamedShape) anAttr =
          Handle(TNaming_NamedShape)::DownCast(anIt.Value());

      if (anAttr.IsNull() == Standard_False) {
        TDF_Label                aLabel = anAttr->Label();
        Handle(TDataStd_Comment) aComment;

        if (aLabel.FindAttribute(TDataStd_Comment::GetID(), aComment)) {
          TCollection_ExtendedString aMatName = aComment->Get();
          TopoDS_Shape               aShape   = anAttr->Get();

          if (aMapMaterialShapes.IsBound(aMatName) == Standard_False) {
            NCollection_List<TopoDS_Shape> anEmptyList;

            aMapMaterialShapes.Bind(aMatName, anEmptyList);
          }

          aMapMaterialShapes(aMatName).Append(aShape);
        }
      }
    }

    if (aMapMaterialShapes.IsEmpty() == Standard_False) {
      // Construct groups.
      TopAbs_ShapeEnum aType = aResShape.ShapeType();
      Standard_Integer i;
      DataMapOfStringListOfShape::Iterator aMapIter;

      // Check each shape type.
      for(i = aType; i <= TopAbs_VERTEX; i++) {
        DataMapOfStringListOfShape::Iterator aMapIter(aMapMaterialShapes);

        for (; aMapIter.More(); aMapIter.Next()) {
          NCollection_List<TopoDS_Shape> &aShList = aMapIter.ChangeValue();
          NCollection_List<TopoDS_Shape>::Iterator aShIter(aShList);
          NCollection_List<TopoDS_Shape>  aShListSameType;

          while (aShIter.More()) {
            const TopoDS_Shape &aShape = aShIter.Value();

            if (i == aShape.ShapeType()) {
              // Treat this element.
              aShListSameType.Append(aShape);
              aShList.Remove(aShIter);
            } else {
              // Go to the next element.
              aShIter.Next();
            }
          }

          if (aShListSameType.IsEmpty() == Standard_False) {
            // Construct a group.
            Handle(GEOM_Object) aGroup =
              MakeGroup(theObject, aMapIter.Key(), aShListSameType);

            if (aGroup.IsNull() == Standard_False) {
              theSeq->Append(aGroup);
            }
          }
        }
      }
    }
  }
}


//=============================================================================
/*!
 *  This method creates a group of shapes of certain type.
 *  \param theObject the imported object.
 *  \param theName the material name.
 *  \param theShapes the list of shapes to be added to this group.
 *  \return the created group.
 */
//=============================================================================
Handle(GEOM_Object) GEOMImpl_IInsertOperations::MakeGroup
                  (const Handle(GEOM_Object)            &theObject,
                   const TCollection_ExtendedString     &theName,
                   const NCollection_List<TopoDS_Shape> &theShapes)
{
  Handle(GEOM_Object)                aGroup;
  TopTools_IndexedMapOfShape         anIndices;
  Handle(TColStd_HSequenceOfInteger) aSeqIDs = new TColStd_HSequenceOfInteger;
  NCollection_List<TopoDS_Shape>::Iterator anIter(theShapes);

  TopExp::MapShapes(theObject->GetValue(), anIndices);

  // Compose shape IDs.
  for (; anIter.More(); anIter.Next()) {
    const TopoDS_Shape &aShape = anIter.Value();
    const Standard_Integer anIndex = anIndices.FindIndex(aShape);

    if (anIndex > 0) {
      aSeqIDs->Append(anIndex);
    }
  }

  if (aSeqIDs->IsEmpty() == Standard_False) {
    // Create a group.
    const TopAbs_ShapeEnum aType  = theShapes.First().ShapeType();

    aGroup = myGroupOperations->CreateGroup(theObject, aType);

    if (aGroup.IsNull() == Standard_False) {
      aGroup->GetLastFunction()->SetDescription("");
      myGroupOperations->UnionIDs(aGroup, aSeqIDs);
      aGroup->GetLastFunction()->SetDescription("");

      // Compose the group name.
      TCollection_AsciiString aGroupName(theName);

      switch(aType) {
        case TopAbs_VERTEX:
          aGroupName += "_VERTEX";
          break;
        case TopAbs_EDGE:
          aGroupName += "_EDGE";
          break;
        case TopAbs_WIRE:
          aGroupName += "_WIRE";
          break;
        case TopAbs_FACE:
          aGroupName += "_FACE";
          break;
        case TopAbs_SHELL:
          aGroupName += "_SHELL";
          break;
        case TopAbs_SOLID:
          aGroupName += "_SOLID";
          break;
        case TopAbs_COMPSOLID:
          aGroupName += "_COMPSOLID";
          break;
        case TopAbs_COMPOUND:
          aGroupName += "_COMPOUND";
          break;
        default:
          aGroupName += "_SHAPE";
          break;
      }

      aGroup->SetName(aGroupName.ToCString());
    }
  }

  return aGroup;
}