FGFS-4.1/OpenSceneGraph
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Introduce the concept of layer set name, using the osg::Object::s/getName() to store

Browse Source 
the setname, and using a compound string (set:setname:filename) in place of standard filename when reading and writing
files.
This commit is contained in:
Robert Osfield
2008-08-28 16:15:57 +00:00
parent c8ef144532
commit ed617f87df
8 changed files with 229 additions and 267 deletions
Download Patch File Download Diff File Expand all files Collapse all files

152
include/osgTerrain/Layer
View File

@@ -26,6 +26,13 @@ namespace osgTerrain {
#define MAXIMUM_NUMBER_OF_LEVELS 30
/** Extact the setname and filename from a compound string in the from set:setname:filename".
* Returns a setname of "" when non set:setname: entry is present.*/
void extractSetNameAndFileName(const std::string& compoundstring, std::string& setname, std::string& filename);
/** Create a compound string in the form set:setname:filename, or just filename if setname is "".*/
std::string createCompondSetNameAndFileName(const std::string& setname, const std::string& filename);
class OSGTERRAIN_EXPORT Layer : public osg::Object
{
public:
@@ -42,7 +49,9 @@ class OSGTERRAIN_EXPORT Layer : public osg::Object
/** Get the file name of the layer. */
virtual const std::string& getFileName() const { return _filename; }
/** Return the compound name of the layer in the form set::name::filename string.*/
std::string getCompoundName() const { return createCompondSetNameAndFileName(getName(), getFileName()); }
void setLocator(Locator* locator) { _locator = locator; }
Locator* getLocator() { return _locator.get(); }
@@ -331,45 +340,6 @@ class OSGTERRAIN_EXPORT HeightFieldLayer : public Layer
};
class OSGTERRAIN_EXPORT CompositeLayer : public Layer
{
public:
CompositeLayer();
/** Copy constructor using CopyOp to manage deep vs shallow copy.*/
CompositeLayer(const CompositeLayer& compositeLayer,const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY);
META_Object(osgTerrain, CompositeLayer);
void clear();
void setFileName(unsigned int i, const std::string& filename) { _layers[i].first = filename; if (_layers[i].second.valid()) _layers[i].second->setFileName(filename); }
const std::string& getFileName(unsigned int i) const { return _layers[i].second.valid() ? _layers[i].second->getFileName() : _layers[i].first; }
void setLayer(unsigned int i, Layer* layer) { _layers[i].second = layer; }
Layer* getLayer(unsigned int i) { return _layers[i].second.get(); }
const Layer* getLayer(unsigned int i) const { return _layers[i].second.get(); }
void addLayer(const std::string& filename) { _layers.push_back(FileNameLayerPair(filename,0)); }
void addLayer(Layer* layer) { _layers.push_back(FileNameLayerPair(layer->getFileName(),layer)); }
void removeLayer(unsigned int i) { _layers.erase(_layers.begin()+i); }
unsigned int getNumLayers() const { return _layers.size(); }
protected:
virtual ~CompositeLayer() {}
typedef std::pair< std::string, osg::ref_ptr<Layer> > FileNameLayerPair;
typedef std::vector< FileNameLayerPair > Layers;
Layers _layers;
};
class OSGTERRAIN_EXPORT ProxyLayer : public Layer
{
public:
@@ -418,9 +388,81 @@ class OSGTERRAIN_EXPORT ProxyLayer : public Layer
};
class OSGTERRAIN_EXPORT CompositeLayer : public Layer
{
public:
CompositeLayer();
/** Copy constructor using CopyOp to manage deep vs shallow copy.*/
CompositeLayer(const CompositeLayer& compositeLayer,const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY);
META_Object(osgTerrain, CompositeLayer);
void clear();
void setSetName(unsigned int i, const std::string& setname) { _layers[i].setname = setname; if (_layers[i].layer.valid()) _layers[i].layer->setName(setname); }
const std::string& getSetName(unsigned int i) const { return _layers[i].layer.valid() ? _layers[i].layer->getName() : _layers[i].setname; }
void setFileName(unsigned int i, const std::string& filename) { _layers[i].filename = filename; if (_layers[i].layer.valid()) _layers[i].layer->setFileName(filename); }
const std::string& getFileName(unsigned int i) const { return _layers[i].layer.valid() ? _layers[i].layer->getFileName() : _layers[i].filename; }
void setCompoundName(unsigned int i, const std::string& compoundname);
std::string getCompoundName(unsigned int i) const;
class OSGTERRAIN_EXPORT SwitchLayer : public Layer
void setLayer(unsigned int i, Layer* layer) { _layers[i].layer = layer; }
Layer* getLayer(unsigned int i) { return _layers[i].layer.get(); }
const Layer* getLayer(unsigned int i) const { return _layers[i].layer.get(); }
void addLayer(const std::string& compoundname);
void addLayer(Layer* layer) { _layers.push_back(CompoundNameLayer(layer->getName(),layer->getFileName(),layer)); }
void removeLayer(unsigned int i) { _layers.erase(_layers.begin()+i); }
unsigned int getNumLayers() const { return _layers.size(); }
protected:
virtual ~CompositeLayer() {}
struct CompoundNameLayer
{
CompoundNameLayer() {}
CompoundNameLayer(const CompoundNameLayer& cnl):
setname(cnl.setname),
filename(cnl.filename),
layer(cnl.layer) {}
CompoundNameLayer(const std::string& sn, const std::string& fn, Layer* l):
setname(sn),
filename(fn),
layer(l) {}
CompoundNameLayer& operator = (const CompoundNameLayer& cnl)
{
if (&cnl==this) return *this;
setname = cnl.setname;
filename = cnl.filename;
layer = cnl.layer;
return *this;
}
std::string setname;
std::string filename;
osg::ref_ptr<Layer> layer;
};
typedef std::vector< CompoundNameLayer > Layers;
Layers _layers;
};
class OSGTERRAIN_EXPORT SwitchLayer : public CompositeLayer
{
public:
@@ -433,36 +475,18 @@ class OSGTERRAIN_EXPORT SwitchLayer : public Layer
void clear();
void setActiveLayer(unsigned int i) { _activeLayer = i; }
unsigned int getActiveLayer() const { return _activeLayer; }
void setFileName(unsigned int i, const std::string& filename) { _layers[i].first = filename; if (_layers[i].second.valid()) _layers[i].second->setFileName(filename); }
const std::string& getFileName(unsigned int i) const { return _layers[i].second.valid() ? _layers[i].second->getFileName() : _layers[i].first; }
void setLayer(unsigned int i, Layer* layer) { _layers[i].second = layer; }
Layer* getLayer(unsigned int i) { return _layers[i].second.get(); }
const Layer* getLayer(unsigned int i) const { return _layers[i].second.get(); }
void addLayer(const std::string& filename) { _layers.push_back(FileNameLayerPair(filename,0)); }
void addLayer(Layer* layer) { _layers.push_back(FileNameLayerPair(layer->getFileName(),layer)); }
void removeLayer(unsigned int i) { _layers.erase(_layers.begin()+i); }
unsigned int getNumLayers() const { return _layers.size(); }
void setActiveLayer(int i) { _activeLayer = i; }
int getActiveLayer() const { return _activeLayer; }
protected:
virtual ~SwitchLayer() {}
typedef std::pair< std::string, osg::ref_ptr<Layer> > FileNameLayerPair;
typedef std::vector< FileNameLayerPair > Layers;
unsigned int _activeLayer;
Layers _layers;
int _activeLayer;
};
}
#endif

2
src/osgPlugins/ive/CompositeLayer.cpp
View File

@@ -42,7 +42,7 @@ void CompositeLayer::write(DataOutputStream* out)
else
{
out->writeBool(false);
out->writeString(getFileName(i));
out->writeString(getCompoundName(i));
}
}
}

48
src/osgPlugins/ive/SwitchLayer.cpp
View File

@@ -13,7 +13,7 @@
#include "Exception.h"
#include "SwitchLayer.h"
#include "Layer.h"
#include "CompositeLayer.h"
using namespace ive;
@@ -23,31 +23,14 @@ void SwitchLayer::write(DataOutputStream* out)
out->writeInt(IVESWITCHLAYER);
// If the osg class is inherited by any other class we should also write this to file.
osgTerrain::Layer* layer = dynamic_cast<osgTerrain::Layer*>(this);
osgTerrain::CompositeLayer* layer = dynamic_cast<osgTerrain::CompositeLayer*>(this);
if (layer)
((ive::Layer*)(layer))->write(out);
((ive::CompositeLayer*)(layer))->write(out);
else
throw Exception("SwitchLayer::write(): Could not cast this osgLayer::SwitchLayer to an osgTerrain::Layer.");
out->writeUInt(getActiveLayer());
LayerHelper helper;
out->writeUInt(getNumLayers());
for(unsigned int i=0; i<getNumLayers(); ++i)
{
if(getLayer(i))
{
out->writeBool(true);
helper.writeLayer(out, getLayer(i));
}
else
{
out->writeBool(false);
out->writeString(getFileName(i));
}
}
out->writeInt(getActiveLayer());
}
void SwitchLayer::read(DataInputStream* in)
@@ -61,28 +44,11 @@ void SwitchLayer::read(DataInputStream* in)
id = in->readInt();
// If the osg class is inherited by any other class we should also read this from file.
osgTerrain::Layer* layer = dynamic_cast<osgTerrain::Layer*>(this);
osgTerrain::CompositeLayer* layer = dynamic_cast<osgTerrain::CompositeLayer*>(this);
if (layer)
((ive::Layer*)(layer))->read(in);
((ive::CompositeLayer*)(layer))->read(in);
else
throw Exception("SwitchLayer::read(): Could not cast this osgLayer::Layer to an osg::Group.");
setActiveLayer(in->readUInt());
LayerHelper helper;
unsigned int numLayers = in->readUInt();
for(unsigned int i=0; i<numLayers; ++i)
{
bool readInlineLayer = in->readBool();
if (readInlineLayer)
{
addLayer(helper.readLayer(in));
}
else
{
addLayer(in->readString());
}
}
setActiveLayer(in->readInt());
}

26
src/osgPlugins/osgTerrain/CompositeLayer.cpp
View File

@@ -75,15 +75,23 @@ bool CompositeLayer_readLocalData(osg::Object& obj, osgDB::Input &fr)
}
else if (fr.matchSequence("ProxyLayer %s") || fr.matchSequence("ProxyLayer %w"))
{
osgTerrain::ProxyLayer* proxyLayer = new osgTerrain::ProxyLayer;
proxyLayer->setFileName(fr[1].getStr());
std::string setname;
std::string filename;
osgTerrain::extractSetNameAndFileName(fr[1].getStr(),setname, filename);
if (!filename.empty())
{
osgTerrain::ProxyLayer* proxyLayer = new osgTerrain::ProxyLayer;
proxyLayer->setFileName(filename);
proxyLayer->setName(setname);
if (locator.valid()) proxyLayer->setLocator(locator.get());
if (minLevel!=0) proxyLayer->setMinLevel(minLevel);
if (maxLevel!=MAXIMUM_NUMBER_OF_LEVELS) proxyLayer->setMaxLevel(maxLevel);
layer.addLayer(proxyLayer);
if (locator.valid()) proxyLayer->setLocator(locator.get());
if (minLevel!=0) proxyLayer->setMinLevel(minLevel);
if (maxLevel!=MAXIMUM_NUMBER_OF_LEVELS) proxyLayer->setMaxLevel(maxLevel);
layer.addLayer(proxyLayer);
}
fr += 2;
itrAdvanced = true;
@@ -145,7 +153,7 @@ bool CompositeLayer_writeLocalData(const osg::Object& obj, osgDB::Output& fw)
fw.indent()<<"MaxLevel "<<proxyLayer->getMaxLevel()<<std::endl;
}
fw.indent()<<"ProxyLayer "<<proxyLayer->getFileName()<<std::endl;
fw.indent()<<"ProxyLayer "<<proxyLayer->getCompoundName()<<std::endl;
}
}
else
@@ -155,7 +163,7 @@ bool CompositeLayer_writeLocalData(const osg::Object& obj, osgDB::Output& fw)
}
else if (!layer.getFileName(i).empty())
{
fw.indent()<<"file "<<layer.getFileName(i)<<std::endl;
fw.indent()<<"file "<<layer.getCompoundName(i)<<std::endl;
}
}

18
src/osgPlugins/osgTerrain/HeightFieldLayer.cpp
View File

@@ -33,12 +33,19 @@ bool HeightFieldLayer_readLocalData(osg::Object& obj, osgDB::Input &fr)
if (fr.matchSequence("file %w") || fr.matchSequence("file %s"))
{
osg::ref_ptr<osg::HeightField> hf = osgDB::readHeightFieldFile(fr[1].getStr());
if (hf.valid())
std::string setname;
std::string filename;
osgTerrain::extractSetNameAndFileName(fr[1].getStr(),setname, filename);
if (!filename.empty())
{
layer.setHeightField(hf.get());
osg::ref_ptr<osg::HeightField> hf = osgDB::readHeightFieldFile(filename);
if (hf.valid())
{
layer.setName(setname);
layer.setFileName(filename);
layer.setHeightField(hf.get());
}
}
fr += 2;
itrAdvanced = true;
}
@@ -61,7 +68,8 @@ bool HeightFieldLayer_writeLocalData(const osg::Object& obj, osgDB::Output& fw)
if (!layer.getFileName().empty())
{
fw.indent()<<"file "<<layer.getFileName()<<std::endl;
std::string str = osgTerrain::createCompondSetNameAndFileName(layer.getName(), layer.getFileName());
fw.indent()<<"file "<< str << std::endl;
}
else
{

19
src/osgPlugins/osgTerrain/ImageLayer.cpp
View File

@@ -33,12 +33,20 @@ bool ImageLayer_readLocalData(osg::Object& obj, osgDB::Input &fr)
if (fr.matchSequence("file %w") || fr.matchSequence("file %s"))
{
osg::ref_ptr<osg::Image> image = osgDB::readImageFile(fr[1].getStr());
if (image.valid())
std::string setname;
std::string filename;
osgTerrain::extractSetNameAndFileName(fr[1].getStr(),setname, filename);
if (!filename.empty())
{
layer.setImage(image.get());
osg::ref_ptr<osg::Image> image = osgDB::readImageFile(filename);
if (image.valid())
{
layer.setName(setname);
layer.setFileName(filename);
layer.setImage(image.get());
}
}
fr += 2;
itrAdvanced = true;
}
@@ -53,7 +61,8 @@ bool ImageLayer_writeLocalData(const osg::Object& obj, osgDB::Output& fw)
if (!layer.getFileName().empty())
{
fw.indent()<<"file "<<layer.getFileName()<<std::endl;
std::string str = osgTerrain::createCompondSetNameAndFileName(layer.getName(), layer.getFileName());
fw.indent()<<"file "<< str << std::endl;
}
return true;

118
src/osgPlugins/osgTerrain/SwitchLayer.cpp
View File

@@ -33,7 +33,7 @@ osgDB::RegisterDotOsgWrapperProxy SwitchLayer_Proxy
(
new osgTerrain::SwitchLayer,
"SwitchLayer",
"Object SwitchLayer Layer",
"Object SwitchLayer CompositeLayer Layer",
SwitchLayer_readLocalData,
SwitchLayer_writeLocalData
);
@@ -43,78 +43,13 @@ bool SwitchLayer_readLocalData(osg::Object& obj, osgDB::Input &fr)
osgTerrain::SwitchLayer& layer = static_cast<osgTerrain::SwitchLayer&>(obj);
bool itrAdvanced = false;
osg::ref_ptr<osgTerrain::Locator> locator = 0;
unsigned int i;
if (fr.read("ActiveLayer",i)) layer.setActiveLayer(i);
do
int i;
if (fr.read("ActiveLayer",i))
{
itrAdvanced = false;
osg::ref_ptr<osg::Object> readObject = fr.readObjectOfType(osgDB::type_wrapper<osgTerrain::Locator>());
locator = dynamic_cast<osgTerrain::Locator*>(readObject.get());
if (readObject.valid()) itrAdvanced = true;
unsigned int minLevel=0;
if (fr.read("MinLevel",minLevel))
{
itrAdvanced = true;
}
unsigned int maxLevel = MAXIMUM_NUMBER_OF_LEVELS;
if (fr.read("MaxLevel",maxLevel))
{
itrAdvanced = true;
}
if (fr.matchSequence("file %s") || fr.matchSequence("file %w") )
{
layer.addLayer(fr[1].getStr());
fr += 2;
itrAdvanced = true;
}
else if (fr.matchSequence("ProxyLayer %s") || fr.matchSequence("ProxyLayer %w"))
{
osgTerrain::ProxyLayer* proxyLayer = new osgTerrain::ProxyLayer;
proxyLayer->setFileName(fr[1].getStr());
if (locator.valid()) proxyLayer->setLocator(locator.get());
if (minLevel!=0) proxyLayer->setMinLevel(minLevel);
if (maxLevel!=MAXIMUM_NUMBER_OF_LEVELS) proxyLayer->setMaxLevel(maxLevel);
layer.addLayer(proxyLayer);
fr += 2;
itrAdvanced = true;
}
else
{
osg::ref_ptr<osg::Object> readObject = fr.readObjectOfType(osgDB::type_wrapper<osgTerrain::Layer>());
osgTerrain::Layer* readLayer = dynamic_cast<osgTerrain::Layer*>(readObject.get());
if (readLayer)
{
if (locator.valid())
{
readLayer->setLocator(locator.get());
locator = 0;
}
if (minLevel!=0) readLayer->setMinLevel(minLevel);
if (maxLevel!=MAXIMUM_NUMBER_OF_LEVELS) readLayer->setMaxLevel(maxLevel);
layer.addLayer(readLayer);
}
if (readObject.valid()) itrAdvanced = true;
}
} while (itrAdvanced);
if (locator.valid()) layer.setLocator(locator.get());
layer.setActiveLayer(i);
itrAdvanced = true;
};
return itrAdvanced;
}
@@ -125,46 +60,5 @@ bool SwitchLayer_writeLocalData(const osg::Object& obj, osgDB::Output& fw)
fw.indent()<<"ActiveLayer "<<layer.getActiveLayer()<<std::endl;
for(unsigned int i=0; i<layer.getNumLayers();++i)
{
if (layer.getLayer(i))
{
const osgTerrain::ProxyLayer* proxyLayer = dynamic_cast<const osgTerrain::ProxyLayer*>(layer.getLayer(i));
if (proxyLayer)
{
if (!proxyLayer->getFileName().empty())
{
const osgTerrain::Locator* locator = proxyLayer->getLocator();
if (locator && !locator->getDefinedInFile())
{
fw.writeObject(*locator);
}
if (proxyLayer->getMinLevel()!=0)
{
fw.indent()<<"MinLevel "<<proxyLayer->getMinLevel()<<std::endl;
}
if (proxyLayer->getMaxLevel()!=MAXIMUM_NUMBER_OF_LEVELS)
{
fw.indent()<<"MaxLevel "<<proxyLayer->getMaxLevel()<<std::endl;
}
fw.indent()<<"ProxyLayer "<<proxyLayer->getFileName()<<std::endl;
}
}
else
{
fw.writeObject(*(layer.getLayer(i)));
}
}
else if (!layer.getFileName(i).empty())
{
fw.indent()<<"file "<<layer.getFileName(i)<<std::endl;
}
}
return true;
}

113
src/osgTerrain/Layer.cpp
View File

@@ -16,6 +16,42 @@
using namespace osgTerrain;
void osgTerrain::extractSetNameAndFileName(const std::string& compoundstring, std::string& setname, std::string& filename)
{
std::string::size_type setcolonpos = compoundstring.find("set:");
if (setcolonpos==std::string::npos)
{
setname = "";
filename = compoundstring;
return;
}
if (compoundstring.size()==4)
{
setname = "";
filename = "";
return;
}
std::string::size_type secondcolonpos = compoundstring.find_first_of(':', setcolonpos+4);
if (secondcolonpos==std::string::npos)
{
setname = compoundstring.substr(setcolonpos+4,std::string::npos);
filename = "";
return;
}
setname = compoundstring.substr(setcolonpos+4,secondcolonpos-setcolonpos-4);
filename = compoundstring.substr(secondcolonpos+1, std::string::npos);
}
std::string osgTerrain::createCompondSetNameAndFileName(const std::string& setname, const std::string& filename)
{
if (setname.empty()) return filename;
return std::string("set:")+setname+std::string(":")+filename;
}
Layer::Layer():
_minLevel(0),
_maxLevel(MAXIMUM_NUMBER_OF_LEVELS),
@@ -456,26 +492,6 @@ unsigned int HeightFieldLayer::getModifiedCount() const
return _modifiedCount;
}
/////////////////////////////////////////////////////////////////////////////
//
// CompositeLayer
//
CompositeLayer::CompositeLayer()
{
}
CompositeLayer::CompositeLayer(const CompositeLayer& compositeLayer,const osg::CopyOp& copyop):
Layer(compositeLayer,copyop)
{
}
void CompositeLayer::clear()
{
_layers.clear();
}
/////////////////////////////////////////////////////////////////////////////
//
// ProxyLayer
@@ -567,24 +583,61 @@ osg::BoundingSphere ProxyLayer::computeBound(bool treatAsElevationLayer) const
}
/////////////////////////////////////////////////////////////////////////////
//
// CompositeLayer
//
CompositeLayer::CompositeLayer()
{
}
CompositeLayer::CompositeLayer(const CompositeLayer& compositeLayer,const osg::CopyOp& copyop):
Layer(compositeLayer,copyop)
{
}
void CompositeLayer::clear()
{
_layers.clear();
}
void CompositeLayer::setCompoundName(unsigned int i, const std::string& compoundname)
{
std::string setname;
std::string filename;
extractSetNameAndFileName(compoundname, setname, filename);
_layers[i].setname = setname;
_layers[i].filename = filename;
}
std::string CompositeLayer::getCompoundName(unsigned int i) const
{
return createCompondSetNameAndFileName(_layers[i].setname, _layers[i].filename);
}
void CompositeLayer::addLayer(const std::string& compoundname)
{
std::string setname;
std::string filename;
extractSetNameAndFileName(compoundname, setname, filename);
_layers.push_back(CompoundNameLayer(setname,filename,0));
}
/////////////////////////////////////////////////////////////////////////////
//
// SwitchLayer
//
SwitchLayer::SwitchLayer():
_activeLayer(0)
_activeLayer(-1)
{
}
SwitchLayer::SwitchLayer(const SwitchLayer& switchLayer,const osg::CopyOp& copyop):
Layer(switchLayer,copyop),
_activeLayer(0)
CompositeLayer(switchLayer,copyop),
_activeLayer(-1)
{
}
void SwitchLayer::clear()
{
_layers.clear();
}