VP1People::Imp Class Reference

Collaboration diagram for VP1People::Imp:

Public Member Functions
	Imp (VP1People *, SoMaterial *mat, SoSeparator *attachsep)
SoSeparator *	loadModel (const std::string &fpath)
double	getScaleFactor (SoNode *node, double desiredHeight)
void	updateFields ()
void	ensureInit3DObjects ()
void	updateColour ()

Public Attributes
VP1People *	theclass
SoMaterial *	material
SoSeparator *	attachSep
bool	shown
SbColor4f	colourAndTransp
double	zpos
double	vertpos
SoSeparator *	sep
SoTranslation *	trans1
SoTranslation *	trans2
SoTranslation *	trans3

Detailed Description

Definition at line 56 of file VP1People.cxx.

Constructor & Destructor Documentation

Imp()

VP1People::Imp::Imp	(	VP1People *	tc,
		SoMaterial *	mat,
		SoSeparator *	attachsep
	)

Definition at line 107 of file VP1People.cxx.

  : theclass(tc), material(mat), attachSep(as), shown(false),
    zpos(0),vertpos(0), sep(0), trans1(0), trans2(0), trans3(0)
{
  material->ref();
  attachSep->ref();
}

Member Function Documentation

ensureInit3DObjects()

void VP1People::Imp::ensureInit3DObjects

(

)

Definition at line 232 of file VP1People.cxx.

{
  if (sep)
    return;
  theclass->messageVerbose("Building 3D objects");
  sep = new SoSeparator; sep->ref();
  sep->addChild(material);
 
 
  // Create people:
  // at first we need to copy the 3D file in the Qt resources file to the local filesystem
  // for the SoQt load method to be able to load it
  // Then, we load the model into the Coin geometry tree
  QTemporaryDir tempDir;
  QFile w1 = QFile(":/vp1/data/models/worker1.wrl");
  QFile w2 = QFile(":/vp1/data/models/worker2.wrl");
  SoSeparator* worker1 = nullptr;
  SoSeparator* worker2 = nullptr;
  if (tempDir.isValid()) {
      const QString tempFile1 = tempDir.path() + "/worker1.wrl";
      if ( w1.copy(tempFile1) ) {
          worker1 = loadModel( tempFile1.toStdString() ); 
      } else {
          std::cout << "ERROR!! QFile copy of Worker1 was NOT successful!\n";
      }
      const QString tempFile2 = tempDir.path() + "/worker2.wrl";
      if ( w2.copy(tempFile2) ) {
          worker2 = loadModel( tempFile2.toStdString() ); 
      } else {
          std::cout << "ERROR!! QFile copy of Worker2 was NOT successful!\n";
      }
  } else {
      std::cout << "ERROR!! TempDir is NOT valid!\n";
  }
  if (worker1 == nullptr) {
      std::cout << "\n\nERROR! The 3D model Worker1 could  not be loaded!\n\n";
      exit(1);
  }
  if (worker2 == nullptr) {
      std::cout << "\n\nERROR! The 3D model Worker2 could  not be loaded!\n\n";
      exit(1);
  }
 
  // TEST CODE with a test shape
  //SoCube* box = new SoCube(); // test shape
  //worker1->materialBinding=SoMaterialBinding::OVERALL;
  //SoMaterialBinding::OVERALL;
  //
  // get the required scale factor for the model
  double scaleFactor1 = getScaleFactor(worker1, 1.80*SYSTEM_OF_UNITS::m);
  double scaleFactor2 = getScaleFactor(worker2, 1.80*SYSTEM_OF_UNITS::m);
  
  // set a scale transformation to apply the required scale factor:
  SoScale* myScale1 = new SoScale();
  myScale1->scaleFactor.setValue(scaleFactor1, scaleFactor1, scaleFactor1);
  SoScale* myScale2 = new SoScale();
  myScale2->scaleFactor.setValue(scaleFactor2, scaleFactor2, scaleFactor2);
 
  // Translation for people models
  trans1 = new SoTranslation;
  trans1->ref();
  trans2 = new SoTranslation;
  trans2->ref();
  trans3 = new SoTranslation;
  trans3->ref();
  
  // rotate the model around the Y axis
  SoRotationXYZ * rotY = new SoRotationXYZ();
  rotY->axis=SoRotationXYZ::Y;
  rotY->angle = 45*SYSTEM_OF_UNITS::deg;
 
  SoVRMLMaterial* matVRML = new SoVRMLMaterial();
  matVRML->diffuseColor.setValue(0., 1., 1.);
 
  // create a separator for the scaled/rotated model,
  // then
  // create a separator for the translated model
  SoSeparator* sepScaledWorker1 = new SoSeparator();
  sepScaledWorker1->addChild(matVRML);
  sepScaledWorker1->addChild(myScale1);
  sepScaledWorker1->addChild(rotY);
  sepScaledWorker1->addChild(worker1);
  //sepScaledWorker1->addChild(box); // test shape
  SoSeparator* sepWorker1 = new SoSeparator();
  sepWorker1->addChild(trans1);
  sepWorker1->addChild(sepScaledWorker1);
 
  SoSeparator* sepScaledWorker2 = new SoSeparator();
  sepScaledWorker2->addChild(myScale2);
  sepScaledWorker2->addChild(rotY);
  sepScaledWorker2->addChild(worker2);
  SoSeparator* sepWorker2 = new SoSeparator();
  sepWorker2->addChild(trans2);
  sepWorker2->addChild(sepScaledWorker2);
 
  SoTranslation* xt = new SoTranslation();
  xt->translation.setValue(2*SYSTEM_OF_UNITS::m, 0., 1*SYSTEM_OF_UNITS::m);
  SoSeparator* sepWorker3 = new SoSeparator();
  sepWorker3->addChild(trans3);
  sepWorker3->addChild(sepScaledWorker1);
  sepWorker3->addChild(xt);
  sepWorker3->addChild(sepScaledWorker2);
  
  // add the scaled model to the scenegraph
  sep->addChild(sepWorker1);
  sep->addChild(sepWorker2);
  sep->addChild(sepWorker3);
}

getScaleFactor()

double VP1People::Imp::getScaleFactor	(	SoNode *	node,
		double	desiredHeight
	)

Definition at line 193 of file VP1People.cxx.

{
 
  // Get the global BoundingBox of the imported model.
  // NOTE: 
  // SoGet-BoundingBoxAction is typically called on a path, 
  // which enables you to obtain a bounding box for a specific object in world coordinates. 
  // This action returns an SbBox3f, 
  // which specifies a 3D box aligned with the x-, y-, and z-axes in world coordinate space. 
  SbViewportRegion dummyViewport; // we need one just for creating the action
  SoGetBoundingBoxAction bboxAction(dummyViewport);
  bboxAction.apply(node);
  SbXfBox3f xfbox = bboxAction.getXfBoundingBox();
  SbBox3f box = xfbox.project();
  float minx, miny, minz, maxx, maxy, maxz;
  box.getBounds(minx, miny, minz, maxx, maxy, maxz);
  float cx,cy,cz;
  box.getCenter().getValue(cx,cy,cz);
 
  // get the height of the model (it's along Y axis)
  float heightModel = (maxy - miny); 
  // set the desired final height for the model
  float heightDesired = desiredHeight;
  // get the required scale scale factor
  double scaleFactor = heightDesired / heightModel;
 
  /*
  // DEBUG MSG
  std::cout << miny << ", " << maxy 
            << ", heightModel: " << heightModel 
            << ", heightDesired: " << heightDesired 
            << ", scaleFactor: " << scaleFactor 
            << std::endl;
  */
  return scaleFactor;
}

loadModel()

SoSeparator * VP1People::Imp::loadModel

(

const std::string &

fpath

)

Definition at line 118 of file VP1People.cxx.

{
    SoDB::init();
    SoInput myInput;
    if (!myInput.openFile(fpath.c_str()))
        exit (1);
    SoSeparator *model = SoDB::readAll(&myInput);
    if (model == NULL)
        exit (1);
 
    unsigned int nChildren = model->getNumChildren();
    std::cout << "nChildren: " << nChildren << std::endl;
    for (unsigned int i=0; i < nChildren; ++i) {
        const SoNode* node = model->getChild(i);
        std::cout << "node " << i << ": " << node << std::endl;
        if (node->getTypeId() == SoVRMLMaterial::getClassTypeId()) {
            std::cout << "Found a SoVRMLMaterial node!\n";
            SoNode * matvrmlnode = (SoVRMLMaterial *)node;  // safe downward cast, knows the type
            std::cout << "Material node: " << matvrmlnode << std::endl;
        }
    }
 
    // WIP
    /*
    SoSearchAction sa;
    sa.setType(SoVRMLMaterial::getClassTypeId());
    sa.setInterest(SoSearchAction::ALL);
    sa.setSearchingAll(TRUE);
    sa.apply(model);
    SoPathList & pl = sa.getPaths();
    SbDict namedict;
    double plLen = pl.getLength();
    std::cout << "plLength: " << plLen << std::endl;
 
    for (int i = 0; i < plLen; i++) {
        
        SoFullPath * p = (SoFullPath*) pl[i];
        
        if (p->getTail()->isOfType(SoVRMLMaterial::getClassTypeId())) {
 
            std::cout << "Found a SoVRMLMaterial node in Search!\n";
            SoVRMLMaterial* vmat = (SoVRMLMaterial*) p->getTail();
           
            if (vmat->filename.getValue().getLength()) {
                SbName name = tex->filename.getValue().getString();
                unsigned long key = (unsigned long) ((void*) name.getString());
                void * tmp;
                if (!namedict.find(key, tmp)) {
                    // new texture. just insert into list
                    (void) namedict.enter(key, tex);
                }
                else if (tmp != (void*) tex) { // replace with node found in dict
                    SoGroup * parent = (SoGroup*) p->getNodeFromTail(1);
                    int idx = p->getIndexFromTail(0);
                    parent->replaceChild(idx, (SoNode*) tmp);
                }
            }
        }
    }
    
    sa.reset();
    
    // output fixed scene to stdout
    SoOutput out;
    SoWriteAction wa(&out);
    wa.apply(model);
    */
 
    return model;
}

updateColour()

void VP1People::Imp::updateColour

(

)

Definition at line 352 of file VP1People.cxx.

{
  theclass->messageVerbose("Updating packed colour");
  if (!sep||sep->getNumChildren()<1)
    return;
  SoNode * n = sep->getChild(0);
  if (!n||n->getTypeId()!=SoVRMLMaterial::getClassTypeId())
    return;
 
  SoVRMLMaterial* matVRML = static_cast<SoVRMLMaterial*>(n);
  matVRML->diffuseColor.setValue( colourAndTransp.getValue() );
}

updateFields()

void VP1People::Imp::updateFields

(

)

Definition at line 342 of file VP1People.cxx.

{
  ensureInit3DObjects();
  theclass->messageVerbose("Updating fields");
  trans1->translation.setValue(0, vertpos, zpos); // x,y,z
  trans2->translation.setValue(4*SYSTEM_OF_UNITS::m, vertpos, zpos); // x,y,z
  trans3->translation.setValue(8*SYSTEM_OF_UNITS::m, vertpos, zpos-10*SYSTEM_OF_UNITS::m); // x,y,z
}

Member Data Documentation

attachSep

SoSeparator* VP1People::Imp::attachSep

Definition at line 63 of file VP1People.cxx.

colourAndTransp

SbColor4f VP1People::Imp::colourAndTransp

Definition at line 69 of file VP1People.cxx.

material

SoMaterial* VP1People::Imp::material

Definition at line 62 of file VP1People.cxx.

sep

SoSeparator* VP1People::Imp::sep

Definition at line 73 of file VP1People.cxx.

shown

bool VP1People::Imp::shown

Definition at line 68 of file VP1People.cxx.

theclass

VP1People* VP1People::Imp::theclass

Definition at line 61 of file VP1People.cxx.

trans1

SoTranslation* VP1People::Imp::trans1

Definition at line 74 of file VP1People.cxx.

trans2

SoTranslation* VP1People::Imp::trans2

Definition at line 75 of file VP1People.cxx.

trans3

SoTranslation* VP1People::Imp::trans3

Definition at line 76 of file VP1People.cxx.

vertpos

double VP1People::Imp::vertpos

Definition at line 71 of file VP1People.cxx.

zpos

double VP1People::Imp::zpos

Definition at line 70 of file VP1People.cxx.

---

The documentation for this class was generated from the following file:

• VP1People.cxx