fileNode.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2004 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: fileNode.h,v $ $Revision: 1.19 $ $State: Exp $
*******************************************************************************/
#ifndef fileNode_H_
#define fileNode_H_

// \file fileNode.h
// \brief Contains the DtFileNode class declaration.

#include "gdb/gdbDefines.h"
#include <stdio.h>

#include <vlutil/vlMachineTypes.h>
#include <vlutil/vlFilename.h>
#include <vector>
#include "geometry/tdbextent.h"
#include "gdb/gdbNode.h"


// Forward declarations
class DtGroup;
class DtTerrainDatabase;
class DtChordBundle;
class DtList;
class DtPoint;
class Coordinate_System;
class DtTriangleIndirect;


//
// Instances of DtFileNode represent a GDB database file nested within another
// GDB database file.
class DT_DLL_gdb DtFileNode : public DtGdbNode
{
public:

   // default constructor
   DtFileNode();

   // Extra constructor if not reading from a file.  This is used so that we
   // can save away the coordinate system and directory of the parent database
   // for use when reading children later.
   DtFileNode(DtTerrainDatabase* parentTerrainDatabase);

   // destructor
   virtual ~DtFileNode();

   // copy constructor
   DtFileNode(const DtFileNode& orig);

   // assignment operator
   DtFileNode& operator=(const DtFileNode& orig);

   // returns the type of gdb node
   virtual DtGdbNodeType type() const;

   // process the polygons included in the node that fall within the input
   // extent, and update the color count in the colorCountRecord which is
   // an in-out parameter.
   virtual void countPolyColors(DtColorCountRecord& cr,
      const DtExtent& e) const;

   // Return a pointer to the parent terrain database (0 if unknown)
   virtual DtTerrainDatabase* parentTerrainDatabase() const;
   // Set the pointer to the parent terrain database
   virtual void setParentTerrainDatabase(DtTerrainDatabase* arg);

   // Returns the extent of the database (if loaded), or the alternate
   // representation (if not loaded).
   virtual DtExtent extent() const;
   
   // Forces the file node to compute or recompute the extent.
   virtual void recomputeExtent();

   // if the terrain is loaded, it will transform it into the new coordinate system.
   virtual bool transformCoordinateSystem(Coordinate_System* newCoordSys);

   virtual void setHomogeneousTransformMatrix(DtHomogeneousTransfMatrix transfMatrix);
   virtual DtHomogeneousTransfMatrix homogeneousTransfMatrix() const;

   virtual void setCreateNewVertices(bool createNewVertices);
   virtual bool createNewVertices() const;

   // redefine extent to include all components of the group
   virtual void expandExtent(DtExtent& e) const;
   virtual void setExtent(DtExtent& e);

   // Returns the child object, either the top terrain object or the alternate
   // representation node.
   virtual DtGdbNode* child() const;

   // Get alternative representation
   virtual DtGroup* alternateRep() const;
   // Set alternative representation
   virtual void setAlternateRep(DtGroup* arg);
   virtual void setAlternateRep(const DtGroup& arg);
   
   // Build an alternate representation from the given terrain
   // NOTE:  Uses the parent terrainDatabase to build the polygons representing
   // the alternate representation.  Parent terrainDatabase must be valid.
   // This is necessary to prevent the polygons representing the terrain
   // from being deleted when the terrain database from which this is created is
   // destroyed.
   virtual bool makeAlternateRepFromTerrain(const DtTerrainDatabase& terrain);
   virtual bool makeAlternateRepFromTerrain(const DtGroup *gp);

   // Take the given terrain as the alternate representation, the top-level
   // DtGdbNode is ripped out of the given terrain object and put in our
   // group. The File node will take over ownership of the terrain database
   // and will delete it when the file node is also destroyed.
   virtual bool takeAlternateRepTerrain(DtTerrainDatabase* terrain);

   // Get filename
   virtual const DtFilename& filename() const;
   // Set filename
   virtual void setFilename(const DtFilename& arg);

   // Get directory of parent database
   virtual const DtFilename& directory() const;
   // Set directory of parent database
   virtual void setDirectory(const DtFilename& arg);

   // Get load failure flag
   virtual bool loadFailed() const;
   // Set load failure flag
   virtual void setLoadFailed(bool arg);

   // Get terrain database (will be 0 if not yet loaded)
   virtual const DtTerrainDatabase* terrainDatabase() const;
   virtual DtTerrainDatabase* terrainDatabase();

   // Set terrain database (this also sets extents and filename)
   virtual void setTerrainDatabase(DtTerrainDatabase* arg);

   // Get the coordinate system
   virtual Coordinate_System* coordinateSystem() const;
   // Set the coordinate system
   virtual void setCoordinateSystem(Coordinate_System* arg);

   // Returns true iff the external terrain file has been loaded
   bool terrainIsLoaded() const;

   // Load in the terrain file.
   // If the member homogeneous transformation is not identity, this will
   // apply the transform to the loaded child database and reset the member
   // transform to identity (as it's been applied) and myCreateNewVertices 
   // to false.
   // If the child coordinate system is different from the parent's coordinate system
   // the child's will be converted if possible.
   virtual bool loadTerrain() const;

   // Unload the terrain file.
   virtual bool unloadTerrain() const;

   // Compute the intersection point of chord and the group.  Note: this
   // forces a load of the terrain file (if possible)
   virtual bool  intersect(const DtChord& chord, 
      DtPoint& intersectionPoint, double& t) const;

   // Computes the intersection of the terrain section represented by the
   // group components and a chord. In addition to the intersection point and
   // a parametric value, optionally computes and returns surface description
   // for the intersecting surface, and normal. Identifies the lowest level
   // intersecting polygon.  This function will only replace the contents of
   // the intersection record if it finds an intersection with a smaller
   // intersectionTime value.
   virtual bool intersect(const DtChord& chord, 
      DtChordIntersectionRecord& record, DtIntersectRecordType irtFlag) const;

   // Computes the list of all intersections of a chord with the terrain
   // section represented by the group components. Adds to a list of
   // DtChordIntersectionRecords sorted by distance along the chord. Returns
   // false if no intersections exist.
   virtual bool allIntersectsAlongChord(const DtChord& chord, 
      DtChordIntersectRecordList& intList,
      DtIntersectRecordType irtFlag) const;

   // Computes the intersection of terrain section represented by the terrain
   // section represented by the group components and a bundle of chords. The
   // returned record list is a a DtList of DtChordIntersectionRecords (one
   // for each chord) each of which must be created and deleted by the caller.
   // The irtFlag value specifies which data should be calculated and returned
   // for each intersection point.  The return value of this function is the
   // number of the chords that had any intersections with the terrain.  This
   // function will only replace the contents of the intersection records if
   // it finds an intersection with a smaller intersectionTime value.
   virtual int intersectBundle(const DtChordBundle& chordBundle,
      DtList& recordList, DtIntersectRecordType irtFlag) const;

   // Computes the list of all intersections of each of a bundle of chords
   // with the terrain section represented by the group components.  For each
   // chord in the bundle, adds to a matching DtChordIntersectRecordList
   // sorted by distance along the chord.  The caller is responsible for
   // creating and deleting the DtChordIntersectRecordLists in the intListList
   // DtList.  The return value of this function is the number of the chords
   // that had any intersections with the terrain.  Note that passing an
   // irtFlag value of IRT_NO_DATA will probably never return more than one
   // intersection per chord.
   virtual int allIntersectsAlongChordBundle(const DtChordBundle& chordBundle,
      DtList& intListList, DtIntersectRecordType irtFlag) const;
 
   // Reduce the group object to eliminate redundant nodes.
   virtual DtGdbNode* reduce(int& numReductions);

   // check the object to ensure it is valid.
   virtual bool sanityCheck() const;

   // Prints out the contents of the object.
   virtual void dump(int indentLevel) const;

   // Finds all instances of node type searchType in the tree including and
   // below this node in it's alternate representation.
   // Does NOT look in the child terrain database.
   virtual void allInstancesOf(const DtGdbNodeType searchType, 
      DtFoundInstancesContainer& foundInstances,
      bool recurseIntoCoordSysNodes = false);

   virtual void allInstancesOf(const DtGdbNodeType searchType, 
      DtFoundInstancesConstContainer& foundInstances,
      bool recurseIntoCoordSysNodes = false) const;

   virtual void allInstancesOf(const DtGdbNodeType searchType, 
      DtFoundInstancesContainer& foundInstances, bool recurseIntoCoordSysNodes, 
      DtGdbNodeEvaluationFunctor& functor);

   virtual void allInstancesOf(const DtGdbNodeType searchType, 
      DtFoundInstancesConstContainer& foundInstances, 
      bool recurseIntoCoordSysNodes, DtGdbNodeEvaluationFunctor& functor) const;


   // Return the minimum terrain file version number that this Node can be
   // saved in.
   virtual DtTerrainFileVersionNumber minSaveVersion() const;

   // Finds and removes all instances of every node type in the tree below
   // this node; deletes the nodes if they are not memory managed.  It returns
   // this.
   virtual DtGdbNode* purgeAll();

   // Load in all external DtFileNode files.  Returns the number of databases
   // that were just loaded.
   virtual unsigned int loadAllExternalFiles() const;

   // Unload all external DtFileNode files.  Returns the number of databases
   // that were unloaded.
   virtual unsigned int unloadAllExternalFiles() const;

   // Find the parent (if it exists of child in the tree under the node)
   virtual DtGdbNode* parent(DtGdbNode *child);

   // remove the child (if it is) from this node
   virtual DtGdbNode* removeChild(DtGdbNode *child);

   // Applies the specified transform to the child terrain database.
   // If the database is not loaded, applies to the node's extent and
   // sets the member transform matrix.  
   // Returns false if the transformation fails for any reason.
   virtual bool applyTransform(const DtHomogeneousTransfMatrix& matrix,
                               bool createNewVertices);

virtual int sizeInBytes() const;

   virtual void buildExtentTriangles();

   virtual DtGroup* extentTriangles();

protected:
   // The child terrain object has just been created, register a
   // terrainModifiedCallback with it so we can pass any changes along to our
   // parent DtTerrainDatabase.
   virtual void registerChildTerrainCallbacks() const;

   // The child terrain object is about to be unloaded, unregister the
   // terrainModifiedCallback.
   virtual void unRegisterChildTerrainCallbacks() const;

   // Tell the parent terrain database that it was modified, either by being
   // loaded or by the child terrain being modified.
   virtual void terrainWasModified(DtTerrainDatabase* terrain,
      const DtExtent& changedVolume) const;

   static void childTerrainModifiedCB(DtTerrainDatabase* terrain,
      const DtExtent& changedVolume, void* usrData);

   virtual void buildExtentTriangle( const DtPoint& v0, const DtPoint& v1, const DtPoint& v2);

protected:
   DtTerrainDatabase* myParentTerrainDatabase;
   DtExtent myExtent;
   DtGroup* myAlternateRep;
   DtFilename myFilename;
   DtFilename myDirectory;
   DtTerrainDatabase* myTerrainDatabase;
   Coordinate_System* myCoordinateSystem;
   // Make this a group!!!
   DtGroup* myExtentTriangles;
   //typedef std::vector<DtTriangleIndirect*> DtExtentTriangles;
   //DtExtentTriangles myExtentTriangles;

   // a homogeneous transform matrix that rotates, scales, and translates
   // the child terrain database when loaded.  Applied to the extent upon
   // being set.
   DtHomogeneousTransfMatrix myHomogeneousTransformMatrix;
   // flag to be used in conjunction with the transformation matrix specifying 
   // whether new vertices should be created or not.
   bool myCreateNewVertices;

   bool myLoadFailed;
   // The following pointer is only used to temporarily hold a pointer to an
   // original database object from which the alternateRep was taken.
   DtTerrainDatabase* myAltTerrainDatabase;
};

#endif