ciTerrain.h

Go to the documentation of this file.

// Copyright JRM Enterprises, Inc. 2004 - 2012
// All rights reserved.
//
// This code is the intellectual property of JRM Enterprises, Inc.
// It may not be used or released as source or compiled binary form
// without the prior written consent of JRM Enterprises, Inc.
//
// Original Author:  Nikolai Fedoroff
// Date:       Oct 2004
//
// $Header: /cvsroot/CommonInterface/CILib/include/ciTerrain.h,v 1.32 2012-02-22 17:50:43 cvsuser Exp $
//
// $Log: not supported by cvs2svn $
// Revision 1.32  2012/02/22 17:50:43  cvsuser
// Add terrain side of brdf
// tr
//
// Revision 1.31  2011-05-02 22:33:20  cvsuser
// (TomG) Added the option into ciTerrain and the config file to use osv's terrain centering with 0,0 in the center of the terrain or just use the classic OSG setup for the terrain.
//
// Revision 1.30  2010/12/04 01:19:31  cvsuser
// Linux build.
// TR
//
// Revision 1.29  2010-08-18 13:07:19  cvsuser
// (Tom G) Changed parse functions to pass clXML by reference in order to remove calls to a copy constructor that was causing major delays.
//
// Revision 1.28  2010/04/22 19:12:08  cvsuser
// CF100422 : SFX & MMLS tweaks & adding lens diffraction and rotation-based scanmask generation
//
// Revision 1.27  2010/03/31 20:11:54  cvsuser
// CF100331 : Added support for reading SFX PIP files.
//
// Revision 1.26  2009/11/09 10:49:30  cvsuser
// (ken) added missing root node
// changed root node to JRM_configuration_file
//
// Revision 1.25  2009/11/05 11:02:17  cvsuser
// (ken) changed to a dll to hopefully allow it to be used with different versions of vc
//
// Revision 1.24  2009/02/27 18:18:20  cvsuser
// (ken) changes for use with VS 2008
// eliminate warnings for stdio routines
//
// Revision 1.23  2008/07/21 18:10:59  cvsuser
// Jon G: Reformated Files to be uniform in respect to tabs and braces. replaceds tabs with spaces.
//
// Revision 1.22  2008/05/14 13:54:54  cvsuser
// Added doxygen tags back into header files for ci module. PS
//
// Revision 1.21  2008/05/02 15:09:46  cvsuser
// Modified ci library to use clXML instead of libxml.  Adjusted project and solution properties and added unit test to ci.  PS
//
// Revision 1.20  2007/11/20 16:47:07  cvsuser
// (ken) Emat initial integration with SigSimC generated emat fractions
//
// Revision 1.19  2007/11/09 12:46:01  cvsuser
// (ken) Emat texture support
// Osg 1.2 updates
// Radar filtering.
//
// Revision 1.18  2007/07/26 01:08:50  cvsuser
// Lod Scale added to the Terrain Panel
//
// Revision 1.17  2007/03/05 18:17:37  cvsuser
// (Tim) added Doxy comments to CI
//
// Revision 1.16  2007/01/05 08:09:17  cvsuser
// (Tim) added xml loading to the ci project
//
// Revision 1.15  2006/12/27 21:09:08  cvsuser
// (Tim) Added set/get for forcing tree billboards.
//
// Revision 1.14  2006/12/06 21:35:50  cvsuser
// CF061206 : Missing #includes, according to my last build. Shouldn't hurt anything if they're already included in some other way.
//
// Revision 1.13  2006/09/04 17:10:22  cvsuser
// (Tim) added a combobox for targeting an entity for movie merge
// changed the atm offeset to altitude in terrain panel
//
// Revision 1.12  2006/05/25 23:48:17  cvsuser
// (Tim)Updated CI for use with wxWidgets-2.6.3
//
// Revision 1.11  2006/05/22 19:50:44  cvsuser
// (Tim)added noise percents along with better noise generation
// added a checkbox for link to TOD
//
// Revision 1.10  2006/01/30 22:31:04  cvsuser
// (Tim) Integrated the SenSim panel into the sensor panel
// Creates a SenSim, Detector, Electronics, and Detector Panel for each sensor
// The SenSim is used from the active sensor
// All sensim panels get saved and loaded independantly
//
// Revision 1.9  2004/11/30 18:16:59  cvsuser
// Tom
//
// Fixed the Movie player file load routine so it works with spaces in the directory name
//
// Added a “Current Working Directory” patch to all panels that specify file inputs via a dialog box.  The file dialog box potentially changed the CWD which could cause problems.  This fix restores the CWD to its state prior to the file operation, there by always keeping the CWD pointing to the start up location of the Asgard executable.
//
// Revision 1.8  2004/11/05 21:59:41  cvsuser
// sgSensor - addeld trackfile checkbox, added position and orientaion data
// sgTerrain - added visibility checkbox
//
// Nik
//
// Revision 1.7  2004/11/03 17:17:15  cvsuser
// Added cicfg load
// fixed some panel bugs
// added panel grid assignement enumerations
//
// Nik
//
// Revision 1.6  2004/11/02 23:03:51  cvsuser
// added "upwards" messaging
// added initialization
//
// Nik
//
// Revision 1.5  2004/10/28 16:16:39  cvsuser
// (Eric) Fixed some capitalization problems
//
// Revision 1.4  2004/10/27 13:40:25  cvsuser
// (Eric) Changed a few syntax issues
//
// Revision 1.3  2004/10/22 14:55:22  cvsuser
// Renamed all ci methods to spec
//
// Nik
//
// Revision 1.2  2004/10/08 21:52:24  cvsuser
// implemented and tested ciTerrain interface class
//
// Nik
//
// Revision 1.1  2004/10/07 21:29:20  cvsuser
// renaming panel files...
//
// Nik
//
//

#if !defined(_ciTerrain_h_)
#define _ciTerrain_h_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include "clXML.h"
#include <stdio.h>
#include "ciApi.h"
#include <iostream>
#include <fstream>
#include <string.h>
#include "clXMLNode.h"

class CI_API ciTerrain  
{
public:     // enumerations

    // enumProjectionType
    enum enumProjectionType
    {
        UTM,   
        LVCS   
    };

    // enumTextureType
    enum enumTextureType
    {
        MCM,   
        EMAT   
    };

public:     // methods

    // getName
    char *getName() {return m_name;}

    // setName
    void setName(const char *name) {strncpy(m_name, name, sizeof(m_name));}

    // getTerrainFilepath
    char *getTerrainFilepath() {return m_terrainFilepath;}

    // setTerrainFilepath
    void setTerrainFilepath(char *terrainFilepath)
    {strncpy(m_terrainFilepath, terrainFilepath, sizeof(m_terrainFilepath));}

    // getProjectionType
    int getProjectionType() {return m_projectionType;}

    // setProjectionType
    void setProjectionType(int projectionType) {
        if ((projectionType >= 0) && (projectionType < (int) sizeof(enumProjectionType)))
            m_projectionType = projectionType;
    }

    // getTextureType
    int getTextureType() {
        if ((m_textureType >= 0) && (m_textureType < (int) sizeof(enumTextureType)))
            return m_textureType;
        else
            return 0;
    }

    // setTextureType
    void setTextureType(int textureType) {
        if ((textureType >= 0) && (textureType < (int) sizeof(enumTextureType)))
            m_textureType = textureType;
    }

    // getSWOrigin
    void getSWOrigin(double &latitude, double &longitude);

    // setSWOrigin
    void setSWOrigin(double latitude, double longitude);

    // getPositionOffset
    void getPositionOffset(double &x, double &y);

    // setPositionOffset
    void setPositionOffset(double x, double y);

    // getMtlsysFilepath
    char *getMtlsysFilepath() {return m_mtlsysFilepath;}

    // setMtlsysFilepath
    void setMtlsysFilepath(char *mtlsysFilepath)
    {strncpy(m_mtlsysFilepath, mtlsysFilepath, sizeof(m_mtlsysFilepath));}

    // getThermalSpinup
    double getThermalSpinup() {return m_thermalSpinup;}

    // setThermalSpinup
    void setThermalSpinup(double thermalSpinup) {m_thermalSpinup = thermalSpinup;}

    // setVisbility
    void setVisbility(bool visibility) {m_visibility = visibility;}

    // getVisbility
    bool getVisbility() {return m_visibility;}

    //getEnableTrees
    bool getEnableTrees() {return m_trees;}
    //setEnableTrees
    void setEnableTrees(bool flag) {m_trees = flag;}
    //getEnableTreeWind
    bool getEnableTreeWind() {return m_treeWind;}
    //setEnableTreeWind
    void setEnableTreeWind(bool flag) {m_treeWind = flag;}
    //getForceTreeBillboards
    bool getForceTreeBillboards() {return m_forceTreeBillboards;}
    //setForceTreeBillboards
    void setForceTreeBillboards(bool flag) {m_forceTreeBillboards = flag;}
    //getEnableTerrainObjects
    bool getEnableTerrainObjects() {return m_terrainObjects;}
    //setEnableTerrainObjects
    void setEnableTerrainObjects(bool flag) {m_terrainObjects = flag;}
    //setAltitude
    void setAltitude(double altitude){m_altitude = altitude;}
    //getAltitude
    double getAltitude(){return m_altitude;}
    //setLodScale
    void setLodScale(double scale){m_lodScale = scale;}
    //getLodScale
    double getLodScale(){return m_lodScale;}


    void setMultiSampleBlending( bool enable )
    {
        m_multiSampleBlending = enable;
    }


    // Get the enable flag for multi-sample blending
    bool getMultiSampleBlending()
    {
        return m_multiSampleBlending;
    }


    //getTerrainCenterEnabled
   bool getTerrainCenterEnabled() { return m_terrainCenterEnabled; }

    //setTerrainCenterEnabled
   void setTerrainCenterEnabled(bool enabled) { m_terrainCenterEnabled = enabled; }


    int getBrdf();
    void setBrdf(int brdf);
    double getRoughness();
    void setRoughness(double roughness);

   int getOptimize();
    void setOptimize(int optimize);

    // archive
    bool archive(std::ofstream &outf);

    // serialize
    bool serialize(char *filepath);

    //
    // loadXML
    //
    // \par Description:
    // Loads attributes from an XML node
    //
    // \param clXMLNode* terrainNode
    // \return
    //
    bool loadXML(clXMLNode* terrainNode);

    //
    // parseXML
    //
    // \par Description:
    // Parses an XML document for specific tags
    //
    // \param clXML xmlDocument
    // \return bool
    //
    bool parseXML(clXML& xmlDocument);

    //loadXMLNode
    bool loadXMLNode(std::string tag, char *nodeString);
    //loadXMLNode
    bool loadXMLNode(std::string tag, bool *nodeBool);
    //loadXMLNode
    bool loadXMLNode(std::string tag, int *nodeBool);
    //loadXMLNode
    bool loadXMLNode(std::string tag, double *nodeBool);

    //
    // saveXML
    //
    // \par Description:
    // Saves XML nodes to an XML document
    //
    // \param clXML* xmlDocument
    //
    void saveXML(clXML* xmlDocument);

    // operator =
    ciTerrain operator = (ciTerrain &obj);

protected:  // methods

public:     // construction/destruction

    // ciTerrain
    ciTerrain();

    // ciTerrain
    ciTerrain(ciTerrain &obj);

    virtual ~ciTerrain();

protected:  // variables

    char m_name[128];         
    char m_terrainFilepath[512]; 
    int     m_projectionType;    
    int     m_textureType;       
    double  m_swOriginLatitude;     
    double  m_swOriginLongitude; 
    double  m_offsetX;             
    double  m_offsetY;             
    char m_mtlsysFilepath[512];  
    double  m_thermalSpinup;     
    bool m_visibility;        
    bool m_trees;
    bool m_treeWind;
    bool m_terrainObjects;
    double  m_altitude;
    bool m_forceTreeBillboards;
    double  m_lodScale;
    bool    m_multiSampleBlending;
    bool m_terrainCenterEnabled; 
    int     m_brdf;
    double  m_roughness;
   int  m_optimize;
    clXMLNode* m_parentNode;
private: // variables

};

#endif // _ciTerrain_h_