Source/System/GraphOp/OSGMergeGraphOp.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *             Copyright (C) 2000-2002 by the OpenSG Forum                   *
   6  *                                                                           *
   7  *                            www.opensg.org                                 *
   8  *                                                                           *
   9  *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
  10  *                                                                           *
  11 \*---------------------------------------------------------------------------*/
  12 /*---------------------------------------------------------------------------*\
  13  *                                License                                    *
  14  *                                                                           *
  15  * This library is free software; you can redistribute it and/or modify it   *
  16  * under the terms of the GNU Library General Public License as published    *
  17  * by the Free Software Foundation, version 2.                               *
  18  *                                                                           *
  19  * This library is distributed in the hope that it will be useful, but       *
  20  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  22  * Library General Public License for more details.                          *
  23  *                                                                           *
  24  * You should have received a copy of the GNU Library General Public         *
  25  * License along with this library; if not, write to the Free Software       *
  26  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
  27  *                                                                           *
  28 \*---------------------------------------------------------------------------*/
  29 /*---------------------------------------------------------------------------*\
  30  *                                Changes                                    *
  31  *                                                                           *
  32  *                                                                           *
  33  *                                                                           *
  34  *                                                                           *
  35  *                                                                           *
  36  *                                                                           *
  37 \*---------------------------------------------------------------------------*/
  38
  39
  40 /***************************************************************************\
  41 *                             Includes                                    *
  42 \***************************************************************************/
  43
  44 #include <boost/bind.hpp>
  45
  46 #include "OSGMergeGraphOp.h"
  47 #include "OSGDirectionalLight.h"
  48 #include "OSGSpotLight.h"
  49 #include "OSGLight.h"
  50 #include "OSGPointLight.h"
  51 #include "OSGSwitch.h"
  52 #include "OSGDistanceLOD.h"
  53 #include "OSGBillboard.h"
  54 #include "OSGMaterialGroup.h"
  55 #include "OSGComponentTransform.h"
  56 #include "OSGPrimitiveIterator.h"
  57 #include "OSGGeometry.h"
  58 #include "OSGGeoFunctions.h"
  59 #include "OSGGraphOpFactory.h"
  60
  61 // need to implement the merge methods amz
  62 #define OSG2_MERGE_MISSING
  63
  64 OSG_USING_NAMESPACE
  65
  66 /***************************************************************************\
  67  *                            Description                                  *
  68 \***************************************************************************/
  69
  70 /*! \class OSG::MergeGraphOp
  71     \ingroup GrpSystemNodeCoresDrawablesGeometry
  72
  73 A class used to optimize geometries a bit.
  74
  75 */
  76
  77 //! Register the GraphOp with the factory
  78 static bool registerOp(void)
  79 {
  80     GraphOpRefPtr newOp = MergeGraphOp::create();
  81
  82     GraphOpFactory::the()->registerOp(newOp);
  83     return true;
  84 }
  85 static OSG::StaticInitFuncWrapper registerOpWrapper(registerOp);
  86
  87 /***************************************************************************\
  88  *                           Instance methods                              *
  89 \***************************************************************************/
  90
  91 /*-------------------------------------------------------------------------*\
  92  -  public                                                                 -
  93 \*-------------------------------------------------------------------------*/
  94
  95
  96 /*------------- constructors & destructors --------------------------------*/
  97
  98 MergeGraphOp::MergeGraphOp(const char* name) :
  99      GraphOp                  (name ),
 100     _color_is_vector          (false),
 101     _secondary_color_is_vector(false),
 102     _texcoord0_is_vector      (false),
 103     _texcoord1_is_vector      (false),
 104     _texcoord2_is_vector      (false),
 105     _texcoord3_is_vector      (false)
 106 {
 107 }
 108
 109 MergeGraphOp::~MergeGraphOp(void)
 110 {
 111 }
 112
 113 MergeGraphOpTransitPtr
 114 MergeGraphOp::create(void)
 115 {
 116     return MergeGraphOpTransitPtr(new MergeGraphOp);
 117 }
 118
 119 GraphOpTransitPtr MergeGraphOp::clone(void)
 120 {
 121     return GraphOpTransitPtr(new MergeGraphOp);
 122 }
 123
 124 UInt32 countNodes(Node * const node)
 125 {
 126     if (node == NULL)
 127         return 0;
 128
 129     UInt32 total = 1;
 130     for (UInt32 i = 0; i < node->getNChildren(); ++i)
 131         total += countNodes(node->getChild(i));
 132     return total;
 133 }
 134
 135 bool MergeGraphOp::traverse(Node * node)
 136 {
 137     // This is a hack and should be treated as such.
 138     // The fact that it helps means there is something wrong with
 139     // the merger. FIXME!!!
 140     UInt32 next = countNodes(node);
 141     SINFO << "MergeGraphOp::traverse: Number of nodes before merge: "
 142           << next << endLog;
 143     bool result = true;
 144     UInt32 current;
 145     do {
 146         current = next;
 147         result &= mergeOnce(node);
 148         if (!result)
 149             break;
 150         next = countNodes(node);
 151     } while (next < current);
 152
 153     SINFO << "MergeGraphOp::traverse: Number of nodes after merge: "
 154           << current << endLog;
 155
 156     return result;
 157 }
 158
 159 void MergeGraphOp::setParams(const std::string params)
 160 {
 161     ParamSet ps(params);
 162
 163     ps("color_is_vector", _color_is_vector);
 164     ps("secondary_color_is_vector", _secondary_color_is_vector);
 165     ps("texcoord_is_vector", _texcoord0_is_vector);
 166     ps("texcoord0_is_vector", _texcoord0_is_vector);
 167     ps("texcoord1_is_vector", _texcoord1_is_vector);
 168     ps("texcoord2_is_vector", _texcoord2_is_vector);
 169     ps("texcoord3_is_vector", _texcoord3_is_vector);
 170
 171     std::string out = ps.getUnusedParams();
 172     if(out.length())
 173     {
 174         FWARNING(("MergeGraphOp doesn't have parameters '%s'.\n",
 175                 out.c_str()));
 176     }
 177 }
 178
 179 std::string MergeGraphOp::usage(void)
 180 {
 181     return
 182     "Merge: merge all geometries in a subtree\n"
 183     "  Tries to merge all Geometries in a subtree into the minimal number.\n"
 184     "  of Nodes. Flattens Transformations and transforms indices on the way.\n"
 185     "Params: name (type, default)\n"
 186     " (The following params are useful for transforming tangent space vectors.)\n"
 187     "  color_is_vector  (bool, false): transform color as if it were a normal\n"
 188     "  secondary_color_is_vector  (bool, false): transform secondary color as if it were a normal\n"
 189     "  texcoord_is_vector  (bool, false): transform texcoord0 as if it were a normal\n"
 190     "  texcoord0_is_vector  (bool, false): transform texcoord0 as if it were a normal\n"
 191     "  texcoord1_is_vector  (bool, false): transform texcoord1 as if it were a normal\n"
 192     "  texcoord2_is_vector  (bool, false): transform texcoord2 as if it were a normal\n"
 193     "  texcoord3_is_vector  (bool, false): transform texcoord3 as if it were a normal\n"
 194     ;
 195 }
 196
 197 /*-------------------------------------------------------------------------*\
 198  -  private                                                                -
 199 \*-------------------------------------------------------------------------*/
 200
 201 bool MergeGraphOp::mergeOnce(Node * node)
 202 {
 203     std::list<Node const *> tempList;
 204     tempList.clear();
 205     tempList.splice(tempList.end(),_excludeListNodes);
 206     makeExcludeList(node);
 207     bool result = GraphOp::traverse(node);
 208     _excludeListNodes.clear();
 209     _excludeListNodes.splice(_excludeListNodes.end(),tempList);
 210     return result;
 211 }
 212
 213 void MergeGraphOp::makeExcludeList(Node * node)
 214 {
 215     /*
 216     ::traverse(node,
 217         osgTypedMethodFunctor1ObjPtrCPtrRef<Action::ResultE,
 218         MergeGraphOp,
 219         NodePtr>(this,&MergeGraphOp::excludeListEnter),
 220         osgTypedMethodFunctor2ObjPtrCPtrRef<Action::ResultE,
 221         MergeGraphOp,
 222         NodePtr,
 223         Action::ResultE>(this,&MergeGraphOp::excludeListLeave));
 224     */
 225     ::traverse(node,
 226                boost::bind(&MergeGraphOp::excludeListEnter, this, _1    ),
 227                boost::bind(&MergeGraphOp::excludeListLeave, this, _1, _2) );
 228 }
 229
 230
 231 Action::ResultE MergeGraphOp::excludeListEnter(Node * const node)
 232 {
 233 //    if (node==NULL) ; else ;
 234     return Action::Continue;
 235 }
 236
 237 Action::ResultE MergeGraphOp::excludeListLeave(Node * const node, Action::ResultE res)
 238 {
 239     DirectionalLight *dlight = dynamic_cast<DirectionalLight *>(node->getCore());
 240     if (dlight!=NULL)
 241         addToExcludeList(dlight->getBeacon());
 242
 243     Light *light = dynamic_cast<Light *>(node->getCore());
 244     if (light!=NULL)
 245         addToExcludeList(light->getBeacon());
 246
 247     PointLight *plight = dynamic_cast<PointLight *>(node->getCore());
 248     if (plight!=NULL)
 249         addToExcludeList(plight->getBeacon());
 250
 251     SpotLight *slight = dynamic_cast<SpotLight *>(node->getCore());
 252     if (slight!=NULL)
 253         addToExcludeList(slight->getBeacon());
 254
 255     return res;
 256 }
 257
 258 Action::ResultE MergeGraphOp::traverseEnter(Node * const node)
 259 {
 260     Switch *switch_ = dynamic_cast<Switch *>(node->getCore());
 261     if (switch_!=NULL) return Action::Skip;
 262
 263     DistanceLOD *dlod = dynamic_cast<DistanceLOD *>(node->getCore());
 264     if (dlod!=NULL) return Action::Skip;
 265
 266     //leaf, don't enter, cause no job here
 267     if (isLeaf(node)) return Action::Skip;
 268
 269     return Action::Continue;
 270 }
 271
 272 Action::ResultE MergeGraphOp::traverseLeave(Node * const node, Action::ResultE res)
 273 {
 274     processGroups(node);
 275     processTransformations(node);
 276     processGeometries(node);
 277     return res;
 278 }
 279
 280 bool MergeGraphOp::isLeaf(Node * const node)
 281 {
 282     if (node->getMFChildren()->begin() ==
 283         node->getMFChildren()->end  ()) return true;
 284     else return false;
 285 }
 286
 287 /*! checks whether a node is a group and nothing else
 288 */
 289 bool MergeGraphOp::isGroup(Node * const node)
 290 {
 291     if(  node->getCore()->getType().isDerivedFrom( Group::getClassType()              ) &&
 292         !node->getCore()->getType().isDerivedFrom( Transform::getClassType()          ) &&
 293         !node->getCore()->getType().isDerivedFrom( ComponentTransform::getClassType() ) &&
 294         !node->getCore()->getType().isDerivedFrom( Switch::getClassType()             ) &&
 295         !node->getCore()->getType().isDerivedFrom( MaterialGroup::getClassType()      ) &&
 296         !node->getCore()->getType().isDerivedFrom( DistanceLOD::getClassType()        ) &&
 297         !node->getCore()->getType().isDerivedFrom( Billboard::getClassType()          ))
 298         return true;
 299     else return false;
 300 }
 301
 302 void MergeGraphOp::processGroups(Node * const node)
 303 {
 304     MFUnrecChildNodePtr::const_iterator mfit = node->getMFChildren()->begin();
 305     MFUnrecChildNodePtr::const_iterator mfen = node->getMFChildren()->end  ();
 306     std::vector<Node *> toAdd;
 307     std::vector<Node *> toSub;
 308
 309     for ( ; mfit != mfen; ++mfit )
 310     {
 311         bool special=isInExcludeList(*mfit);
 312         bool leaf=isLeaf(*mfit);
 313
 314         if (isGroup(*mfit))
 315         {
 316             if (!leaf && !special)
 317             {
 318                 MFUnrecChildNodePtr::const_iterator it2 =
 319                     (*mfit)->getMFChildren()->begin();
 320                 MFUnrecChildNodePtr::const_iterator en2 =
 321                     (*mfit)->getMFChildren()->end  ();
 322
 323                 for ( ; it2 != en2; ++it2 )
 324                 {
 325                     toAdd.push_back(*it2);
 326                 }
 327             }
 328
 329             if (!special)
 330             {
 331                 toSub.push_back(*mfit);
 332                 continue;
 333             }
 334
 335             if (leaf && special)
 336             {
 337                 //what to do?
 338             }
 339             if (!leaf && special)
 340             {
 341                 //what to do?
 342             }
 343             continue;
 344         }
 345         else if ((*mfit)->getCore()->getType().isDerivedFrom(
 346                      MaterialGroup::getClassType() ))
 347         {
 348             MaterialGroup *mg =
 349                 dynamic_cast<MaterialGroup *>((*mfit)->getCore());
 350
 351             MFUnrecChildNodePtr::const_iterator it2 =
 352                 (*mfit)->getMFChildren()->begin();
 353             MFUnrecChildNodePtr::const_iterator en2 =
 354                 (*mfit)->getMFChildren()->end  ();
 355
 356             bool empty=true;
 357
 358             for ( ; it2 != en2; ++it2 )
 359             {
 360                 if (!isInExcludeList(*it2))
 361                 {
 362                     //check if geometry
 363                     if ((*it2)->getCore()->getType().isDerivedFrom(
 364                             Geometry::getClassType()))
 365                     {
 366                         if(!isLeaf(*it2))
 367                         {
 368                             //hmm...bad tree...
 369                             empty=false;
 370                         }
 371                         else
 372                         {
 373                             //it is a leaf geometry, so apply the transformation
 374                             Geometry *geo =
 375                                 dynamic_cast<Geometry *>((*it2)->getCore());
 376
 377                             geo->setMaterial(mg->getMaterial());
 378
 379                             toAdd.push_back(*it2);
 380                         }
 381                     }
 382                     else
 383                     {
 384                         empty=false;
 385                     }
 386                 }
 387                 else
 388                 {
 389                     empty=false;
 390                 }
 391             }
 392
 393             if (empty)
 394                 toSub.push_back(*mfit);
 395         }
 396     }
 397
 398     std::vector<Node *>::const_iterator vit = toAdd.begin();
 399     std::vector<Node *>::const_iterator ven = toAdd.end  ();
 400
 401     for ( ; vit != ven; ++vit )
 402     {
 403         node->addChild(*vit);
 404     }
 405
 406     vit = toSub.begin();
 407     ven = toSub.end  ();
 408
 409     for ( ; vit != ven; ++vit )
 410     {
 411         node->subChild(*vit);
 412     }
 413 }
 414
 415 void MergeGraphOp::processTransformations(Node * const node)
 416 {
 417     MFUnrecChildNodePtr::const_iterator mfit = node->getMFChildren()->begin();
 418     MFUnrecChildNodePtr::const_iterator mfen = node->getMFChildren()->end  ();
 419     std::vector<Node *> toAdd;
 420     std::vector<Node *> toSub;
 421
 422     for ( ; mfit != mfen; ++mfit )
 423     {
 424         bool special=isInExcludeList(*mfit);
 425         bool leaf=isLeaf(*mfit);
 426         bool empty=true;
 427
 428         //if a transformation:
 429         if ((*mfit)->getCore()->getType().isDerivedFrom(
 430                 Transform::getClassType()))
 431         {
 432             if (!leaf && !special)
 433             {
 434                 //try to apply it to children geometries
 435                 //move all "moveable" children one level up
 436                 //if empty after that, delete it
 437                 MFUnrecChildNodePtr::const_iterator it2 =
 438                     (*mfit)->getMFChildren()->begin();
 439                 MFUnrecChildNodePtr::const_iterator en2 =
 440                     (*mfit)->getMFChildren()->end  ();
 441
 442                 for ( ; it2 != en2; ++it2 )
 443                 {
 444                     if (!isInExcludeList(*it2))
 445                     {
 446                         //check if geometry
 447                         if ((*it2)->getCore()->getType().isDerivedFrom(
 448                                 Geometry::getClassType()))
 449                         {
 450                             if(!isLeaf(*it2))
 451                             {
 452                                 //hmm...bad tree...
 453                                 empty=false;
 454                             }
 455                             else
 456                             {
 457                                 //it is a leaf geometry, so apply the transformation
 458                                 Geometry *geo_old =
 459                                     dynamic_cast<Geometry *>(
 460                                         (*it2)->getCore());
 461                                 //GeometryPtr geo = geo_old->clone();
 462                                 GeometryUnrecPtr geo =
 463                                     dynamic_pointer_cast<Geometry>(
 464                                         OSG::deepClone(geo_old, "Material"));
 465
 466                                 Transform *t =
 467                                     dynamic_cast<Transform *>(
 468                                         (*mfit)->getCore());
 469
 470                                 GeoPnt3fProperty *pos  = dynamic_cast<GeoPnt3fProperty *>(geo->getPositions());
 471                                 GeoVec3fProperty *norm = dynamic_cast<GeoVec3fProperty *>(geo->getNormals());
 472                                 GeoColor3fProperty *color = dynamic_cast<GeoColor3fProperty *>(geo->getColors());
 473                                 GeoColor3fProperty *scolor = dynamic_cast<GeoColor3fProperty *>(geo->getSecondaryColors());
 474                                 GeoVec3fProperty *texcoord0 = dynamic_cast<GeoVec3fProperty *>(geo->getTexCoords());
 475                                 GeoVec3fProperty *texcoord1 = dynamic_cast<GeoVec3fProperty *>(geo->getTexCoords1());
 476                                 GeoVec3fProperty *texcoord2 = dynamic_cast<GeoVec3fProperty *>(geo->getTexCoords2());
 477                                 GeoVec3fProperty * texcoord3 = dynamic_cast<GeoVec3fProperty *>(geo->getTexCoords3());
 478
 479                                 Matrix m=t->getMatrix();
 480
 481                                 if(pos!=NULL)
 482                                 {
 483                                     for(UInt32 i = 0; i < pos->size(); ++i)
 484                                     {
 485                                         Pnt3f p=pos->getValue(i);
 486                                         m.multFull(p, p);
 487                                         pos->setValue(p,i);
 488                                     }
 489                                 }
 490
 491                                 if(norm!=NULL)
 492                                 {
 493                                     for(UInt32 i = 0; i < norm->size(); ++i)
 494                                     {
 495                                         Vec3f n=norm->getValue(i);
 496                                         m.mult(n, n);
 497                                         n.normalize();
 498                                         norm->setValue(n,i);
 499                                     }
 500                                 }
 501
 502                                 if(color != NULL && _color_is_vector)
 503                                 {
 504                                     for(UInt32 i = 0; i < color->size(); ++i)
 505                                     {
 506                                         Color3f c = color->getValue(i);
 507                                         Vec3f v;
 508                                         v.setValue(c.getValuesRGB());
 509                                         m.mult(v, v);
 510                                         v.normalize();
 511                                         c.setValuesRGB(v[0], v[1], v[2]);
 512                                         color->setValue(c,i);
 513                                     }
 514                                 }
 515
 516                                 if(scolor != NULL && _secondary_color_is_vector)
 517                                 {
 518                                     for(UInt32 i = 0; i < scolor->size(); ++i)
 519                                     {
 520                                         Color3f c = scolor->getValue(i);
 521                                         Vec3f v;
 522                                         v.setValue(c.getValuesRGB());
 523                                         m.mult(v, v);
 524                                         v.normalize();
 525                                         c.setValuesRGB(v[0], v[1], v[2]);
 526                                         scolor->setValue(c,i);
 527                                     }
 528                                 }
 529
 530                                 if(texcoord0 != NULL && _texcoord0_is_vector)
 531                                 {
 532                                     for(UInt32 i = 0; i < texcoord0->size(); ++i)
 533                                     {
 534                                         Vec3f v = texcoord0->getValue(i);
 535                                         m.mult(v, v);
 536                                         v.normalize();
 537                                         texcoord0->setValue(v,i);
 538                                     }
 539                                 }
 540
 541                                 if(texcoord1 != NULL && _texcoord1_is_vector)
 542                                 {
 543                                     for(UInt32 i = 0; i < texcoord1->size(); ++i)
 544                                     {
 545                                         Vec3f v = texcoord1->getValue(i);
 546                                         m.mult(v, v);
 547                                         v.normalize();
 548                                         texcoord1->setValue(v,i);
 549                                     }
 550                                 }
 551
 552                                 if(texcoord2 != NULL && _texcoord2_is_vector)
 553                                 {
 554                                     for(UInt32 i = 0; i < texcoord2->size(); ++i)
 555                                     {
 556                                         Vec3f v = texcoord2->getValue(i);
 557                                         m.mult(v, v);
 558                                         v.normalize();
 559                                         texcoord2->setValue(v,i);
 560                                     }
 561                                 }
 562
 563                                 if (texcoord3 != NULL && _texcoord3_is_vector)
 564                                 {
 565                                     for(UInt32 i = 0; i < texcoord3->size(); i++)
 566                                     {
 567                                         Vec3f v = texcoord3->getValue(i);
 568                                         m.mult(v, v);
 569                                         v.normalize();
 570                                         texcoord3->setValue(v,i);
 571                                     }
 572                                 }
 573                                 (*it2)->setCore(geo);
 574                                 toAdd.push_back(*it2);
 575                             }
 576                         } else empty=false;
 577                     } else empty=false;
 578                 }
 579             }
 580
 581             //now check whether we have to remove it
 582             if ((empty||leaf) && !special)
 583             {
 584                 toSub.push_back(*mfit);
 585                 continue;
 586             }
 587
 588             if (leaf && special)
 589             {
 590                 //what to do?
 591             }
 592             if (!leaf && special)
 593             {
 594                 //what to do?
 595             }
 596             continue;
 597         }
 598     }
 599
 600     std::vector<Node *>::const_iterator vit = toAdd.begin();
 601     std::vector<Node *>::const_iterator ven = toAdd.end  ();
 602
 603     for ( ; vit != ven; ++vit )
 604     {
 605         node->addChild(*vit);
 606     }
 607
 608     vit = toSub.begin();
 609     ven = toSub.end  ();
 610
 611     for ( ; vit != ven; ++vit )
 612     {
 613         node->subChild(*vit);
 614     }
 615 }
 616
 617 void MergeGraphOp::processGeometries(Node * const node)
 618 {
 619     MFUnrecChildNodePtr::const_iterator mfit = node->getMFChildren()->begin();
 620     MFUnrecChildNodePtr::const_iterator mfen = node->getMFChildren()->end  ();
 621
 622     std::vector<Node        *> toSub;
 623     std::vector<NodeUnrecPtr > toAdd;
 624
 625     for ( ; mfit != mfen; ++mfit )
 626     {
 627         bool special=isInExcludeList(*mfit);
 628
 629         if ((*mfit)->getCore()->getType().isDerivedFrom(
 630                 Geometry::getClassType()))
 631         {
 632 #ifndef OSG2_MERGE_MISSING
 633             Geometry *geo = dynamic_cast<Geometry *>((*mfit)->getCore());
 634 #endif
 635             //if a geometry, try to merge it in another geometry
 636             //if successfull, delete it.
 637             //check also if it is added for exclusion
 638
 639             bool inSubList=false;
 640
 641             std::vector<Node *>::const_iterator it3=toSub.begin();
 642             std::vector<Node *>::const_iterator en3=toSub.end();
 643
 644             for ( ; it3 != en3; ++it3 )
 645                 if (*it3==*mfit) { inSubList=true; break; }
 646
 647             if (!special && !inSubList)
 648             {
 649                 //ok, try
 650                 MFUnrecChildNodePtr::const_iterator it2=mfit+1;
 651                 Geometry *new_geo=NULL;
 652                 for ( ; it2!=mfen; ++it2)
 653                 {
 654                     if (!isInExcludeList(*it2) && (*it2)->getCore()->getType().isDerivedFrom(Geometry::getClassType()))
 655                     {
 656 #ifndef OSG2_MERGE_MISSING
 657                         Geometry *geo2 = dynamic_cast<Geometry *>((*it2)->getCore());
 658                         if (geo->isMergeable(geo2))
 659                         {
 660                             // HACK merge crashes when indices == NULL!
 661                             if(geo->getIndices() == NULL)
 662                                 OSG::createSharedIndex(geo);
 663                             if(geo2->getIndices() == NULL)
 664                                 OSG::createSharedIndex(geo2);
 665                             if (new_geo==NULL)
 666                             {
 667                                 new_geo=Geometry::create();
 668                                 if (new_geo->merge(geo))
 669                                     toSub.push_back(*it);
 670                                 else FWARNING(("MergeGraphOp: processGeometries problem 1\n"));
 671
 672                                 if (new_geo->merge(geo2))
 673                                     toSub.push_back(*it2);
 674                                 else FWARNING(("MergeGraphOp: processGeometries problem 2\n"));
 675                             }
 676                             else
 677                             {
 678                                 if (new_geo->merge(geo2))
 679                                     toSub.push_back(*it2);
 680                             }
 681                         }
 682 #endif
 683                     }
 684                 }
 685                 if (new_geo!=NULL)
 686                 {
 687                     NodeUnrecPtr new_node=Node::create();
 688                     new_node->setCore(new_geo);
 689
 690                     toAdd.push_back(new_node);
 691                 }
 692             }
 693             else
 694             {
 695                 //hmm...have to skip it
 696             }
 697         }
 698     }
 699
 700     std::vector<NodeUnrecPtr>::const_iterator ait = toAdd.begin();
 701     std::vector<NodeUnrecPtr>::const_iterator aen = toAdd.end  ();
 702
 703     for ( ; ait != aen; ++ait )
 704     {
 705         node->addChild(*ait);
 706     }
 707
 708     std::vector<Node *>::const_iterator sit = toSub.begin();
 709     std::vector<Node *>::const_iterator sen = toSub.end  ();
 710
 711     for ( ; sit != sen; ++sit )
 712     {
 713         node->subChild(*sit);
 714     }
 715 }