Changeset 930

Show
Ignore:
Timestamp:
09/02/08 14:56:18
Author:
robert
Message:

Added setting of Source's new SetName? field from osgTerrain::Layer'sSetName

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/include/vpb/Destination

    r886 r930  
    111111    void setMaximumImagerySize(unsigned int maxNumColumns,unsigned int maxNumRows) 
    112112    { 
    113         _imagery_maxNumColumns = maxNumColumns; 
    114         _imagery_maxNumRows = maxNumRows; 
     113        _image_maxNumColumns = maxNumColumns; 
     114        _image_maxNumRows = maxNumRows; 
    115115    } 
    116116 
     
    180180    { 
    181181        ImageData(): 
    182             _imagery_maxSourceResolutionX(0.0f), 
    183             _imagery_maxSourceResolutionY(0.0f) {} 
    184  
    185  
    186         float                                  _imagery_maxSourceResolutionX; 
    187         float                                  _imagery_maxSourceResolutionY; 
    188  
    189         osg::ref_ptr<DestinationData>          _imagery
     182            _image_maxSourceResolutionX(0.0f), 
     183            _image_maxSourceResolutionY(0.0f) {} 
     184 
     185 
     186        float                                  _image_maxSourceResolutionX; 
     187        float                                  _image_maxSourceResolutionY; 
     188 
     189        osg::ref_ptr<DestinationData>          _imageDestination
    190190    }; 
    191191 
     192    struct ImageSet 
     193    { 
     194        ImageSet(): 
     195            _optional(false), 
     196            _image_maxSourceResolutionX(0.0f), 
     197            _image_maxSourceResolutionY(0.0f) {} 
     198 
     199        typedef std::map<std::string, ImageData> LayerSetImageDataMap; 
     200        LayerSetImageDataMap                    _layerSetImageDataMap; 
     201         
     202        bool                                    _optional; 
     203 
     204        float                                   _image_maxSourceResolutionX; 
     205        float                                   _image_maxSourceResolutionY; 
     206    }; 
     207 
    192208    std::vector<ImageData>                      _imagery; 
     209    std::vector<ImageSet>                       _imagerySet; 
    193210 
    194211    inline ImageData& getImageData(unsigned int layer) 
     
    198215    } 
    199216 
     217    inline ImageSet& getImageSet(unsigned int layer) 
     218    { 
     219        if (layer>=_imagerySet.size()) _imagerySet.resize(layer+1); 
     220        return _imagerySet[layer]; 
     221    } 
     222 
    200223    osg::ref_ptr<DestinationData>               _terrain; 
    201224    osg::ref_ptr<DestinationData>               _models; 
     
    207230    unsigned int                                _maxSourceLevel; 
    208231 
    209     unsigned int                                _imagery_maxNumColumns; 
    210     unsigned int                                _imagery_maxNumRows; 
     232    unsigned int                                _image_maxNumColumns; 
     233    unsigned int                                _image_maxNumRows; 
    211234 
    212235    unsigned int                                _terrain_maxNumColumns; 
  • trunk/include/vpb/Source

    r843 r930  
    8383    Type getType() const { return _type; } 
    8484 
     85    void setSetName(const std::string& setname) { _setname = setname; } 
     86    const std::string& getSetName() const { return _setname; } 
     87 
    8588    void setFileName(const std::string& filename) { _filename = filename; } 
    8689    const std::string& getFileName() const { return _filename; } 
     
    210213    double                                      _sortValue; 
    211214 
     215    std::string                                 _setname; 
    212216    std::string                                 _filename; 
    213217    bool                                        _temporaryFile; 
  • trunk/src/vpb/DataSet.cpp

    r925 r930  
    806806            if (tile->computeImageResolution(layerNum,texture_numColumns,texture_numRows,texture_dx,texture_dy)) 
    807807            { 
    808                 if (texture_dx*resolutionSensitivityScale>tile->_imagery[layerNum]._imagery_maxSourceResolutionX) needToDivideX = true; 
    809                 if (texture_dy*resolutionSensitivityScale>tile->_imagery[layerNum]._imagery_maxSourceResolutionY) needToDivideY = true; 
     808                if (texture_dx*resolutionSensitivityScale>tile->_imagery[layerNum]._image_maxSourceResolutionX) needToDivideX = true; 
     809                if (texture_dy*resolutionSensitivityScale>tile->_imagery[layerNum]._image_maxSourceResolutionY) needToDivideY = true; 
    810810            } 
    811811        } 
     
    19931993        // need to read locator. 
    19941994        vpb::Source* source = new vpb::Source(type, hfl->getFileName()); 
     1995        source->setSetName(hfl->getSetName()); 
    19951996        source->setLayer(layerNum); 
    19961997        source->setMinLevel(layer->getMinLevel()); 
     
    20192020        // need to read locator 
    20202021        vpb::Source* source = new vpb::Source(type, iml->getFileName()); 
     2022        source->setSetName(iml->getSetName()); 
    20212023        source->setLayer(layerNum); 
    20222024        source->setMinLevel(layer->getMinLevel()); 
     
    20472049 
    20482050        vpb::Source* source = new vpb::Source(type, pl->getFileName()); 
     2051        source->setSetName(pl->getSetName()); 
    20492052        source->setLayer(layerNum); 
    20502053        source->setMinLevel(layer->getMinLevel()); 
     
    20802083            { 
    20812084                vpb::Source* source = new vpb::Source(type, compositeLayer->getFileName(i)); 
     2085                source->setSetName(compositeLayer->getSetName(i)); 
    20822086                source->setMinLevel(layer->getMinLevel()); 
    20832087                source->setMaxLevel(layer->getMaxLevel()); 
  • trunk/src/vpb/Destination.cpp

    r908 r930  
    8282    _pixelFormat(GL_RGB), 
    8383    _maxSourceLevel(0), 
    84     _imagery_maxNumColumns(4096), 
    85     _imagery_maxNumRows(4096), 
     84    _image_maxNumColumns(4096), 
     85    _image_maxNumRows(4096), 
    8686    _terrain_maxNumColumns(1024), 
    8787    _terrain_maxNumRows(1024), 
     
    142142                { 
    143143                    ImageData& imageData = getImageData(source->getLayer()); 
    144                     if (imageData._imagery_maxSourceResolutionX==0.0f) imageData._imagery_maxSourceResolutionX=sourceResolutionX; 
    145                     else imageData._imagery_maxSourceResolutionX=osg::minimum(imageData._imagery_maxSourceResolutionX,sourceResolutionX); 
    146                     if (imageData._imagery_maxSourceResolutionY==0.0f) imageData._imagery_maxSourceResolutionY=sourceResolutionY; 
    147                     else imageData._imagery_maxSourceResolutionY=osg::minimum(imageData._imagery_maxSourceResolutionY,sourceResolutionY); 
     144                    if (imageData._image_maxSourceResolutionX==0.0f) imageData._image_maxSourceResolutionX=sourceResolutionX; 
     145                    else imageData._image_maxSourceResolutionX=osg::minimum(imageData._image_maxSourceResolutionX,sourceResolutionX); 
     146                    if (imageData._image_maxSourceResolutionY==0.0f) imageData._image_maxSourceResolutionY=sourceResolutionY; 
     147                    else imageData._image_maxSourceResolutionY=osg::minimum(imageData._image_maxSourceResolutionY,sourceResolutionY); 
    148148                    break; 
    149149                } 
     
    183183{ 
    184184    ImageData& imageData = getImageData(layer); 
    185     if (imageData._imagery_maxSourceResolutionX!=0.0f && imageData._imagery_maxSourceResolutionY!=0.0f && 
    186         _imagery_maxNumColumns!=0 && _imagery_maxNumRows!=0) 
     185    if (imageData._image_maxSourceResolutionX!=0.0f && imageData._image_maxSourceResolutionY!=0.0f && 
     186        _image_maxNumColumns!=0 && _image_maxNumRows!=0) 
    187187    { 
    188188        // set up properly for vector and raster (previously always vector) 
     
    192192        if (_dataType == SpatialProperties::VECTOR) 
    193193        { 
    194             numColumnsAtFullRes = 1+(unsigned int)ceilf((_extents.xMax()-_extents.xMin())/imageData._imagery_maxSourceResolutionX); 
    195             numRowsAtFullRes = 1+(unsigned int)ceilf((_extents.yMax()-_extents.yMin())/imageData._imagery_maxSourceResolutionY); 
     194            numColumnsAtFullRes = 1+(unsigned int)ceilf((_extents.xMax()-_extents.xMin())/imageData._image_maxSourceResolutionX); 
     195            numRowsAtFullRes = 1+(unsigned int)ceilf((_extents.yMax()-_extents.yMin())/imageData._image_maxSourceResolutionY); 
    196196        } 
    197197        else    // if (_dataType == SpatialProperties::RASTER) 
    198198        { 
    199             numColumnsAtFullRes = (unsigned int)ceilf((_extents.xMax()-_extents.xMin())/imageData._imagery_maxSourceResolutionX); 
    200             numRowsAtFullRes = (unsigned int)ceilf((_extents.yMax()-_extents.yMin())/imageData._imagery_maxSourceResolutionY); 
    201         } 
    202  
    203         unsigned int numColumnsRequired = osg::minimum(_imagery_maxNumColumns,numColumnsAtFullRes); 
    204         unsigned int numRowsRequired    = osg::minimum(_imagery_maxNumRows,numRowsAtFullRes); 
     199            numColumnsAtFullRes = (unsigned int)ceilf((_extents.xMax()-_extents.xMin())/imageData._image_maxSourceResolutionX); 
     200            numRowsAtFullRes = (unsigned int)ceilf((_extents.yMax()-_extents.yMin())/imageData._image_maxSourceResolutionY); 
     201        } 
     202 
     203        unsigned int numColumnsRequired = osg::minimum(_image_maxNumColumns,numColumnsAtFullRes); 
     204        unsigned int numRowsRequired    = osg::minimum(_image_maxNumRows,numRowsAtFullRes); 
    205205 
    206206        // use a minimum image size of 4x4 to avoid mipmap generation problems in OpenGL at sizes at 2x2.  
     
    285285            ImageData& imageData = getImageData(layerNum); 
    286286 
    287             imageData._imagery = new DestinationData(_dataSet); 
    288             imageData._imagery->_cs = _cs; 
    289             imageData._imagery->_extents = _extents; 
    290             imageData._imagery->_geoTransform.set(texture_dx,      0.0,               0.0,0.0, 
     287            imageData._imageDestination = new DestinationData(_dataSet); 
     288            imageData._imageDestination->_cs = _cs; 
     289            imageData._imageDestination->_extents = _extents; 
     290            imageData._imageDestination->_geoTransform.set(texture_dx,      0.0,               0.0,0.0, 
    291291                                        0.0,             -texture_dy,       0.0,0.0, 
    292292                                        0.0,             0.0,               1.0,1.0, 
     
    294294 
    295295 
    296             imageData._imagery->_image = new osg::Image; 
     296            imageData._imageDestination->_image = new osg::Image; 
    297297 
    298298            std::string imageName(_name+_dataSet->getDestinationImageExtension()); 
    299             imageData._imagery->_image->setFileName(imageName.c_str()); 
    300  
    301             imageData._imagery->_image->allocateImage(texture_numColumns,texture_numRows,1,_pixelFormat,GL_UNSIGNED_BYTE); 
    302             unsigned char* data = imageData._imagery->_image->data(); 
    303             unsigned int totalSize = imageData._imagery->_image->getTotalSizeInBytesIncludingMipmaps(); 
     299            imageData._imageDestination->_image->setFileName(imageName.c_str()); 
     300 
     301            imageData._imageDestination->_image->allocateImage(texture_numColumns,texture_numRows,1,_pixelFormat,GL_UNSIGNED_BYTE); 
     302            unsigned char* data = imageData._imageDestination->_image->data(); 
     303            unsigned int totalSize = imageData._imageDestination->_image->getTotalSizeInBytesIncludingMipmaps(); 
    304304            for(unsigned int i=0;i<totalSize;++i) 
    305305            { 
     
    450450            { 
    451451                ImageData& imageData = tcp.first->_imagery[layerNum]; 
    452                 if (imageData._imagery.valid() && imageData._imagery->_image.valid()) 
     452                if (imageData._imageDestination.valid() && imageData._imageDestination->_image.valid()) 
    453453                { 
    454                     imagesToProcess.push_back(ImageCornerPair(imageData._imagery->_image.get(),tcp.second)); 
     454                    imagesToProcess.push_back(ImageCornerPair(imageData._imageDestination->_image.get(),tcp.second)); 
    455455                } 
    456456            } 
     
    653653    { 
    654654        // do we have a image to equalize? 
    655         if (!_imagery[layerNum]._imagery.valid()) continue; 
     655        if (!_imagery[layerNum]._imageDestination.valid()) continue; 
    656656         
    657657        // does the neighbouring tile have an image to equalize? 
    658658        if (layerNum>=tile2->_imagery.size()) continue; 
    659         if (!(tile2->_imagery[layerNum]._imagery.valid())) continue; 
    660      
    661  
    662         osg::Image* image1 = _imagery[layerNum]._imagery->_image.get(); 
    663         osg::Image* image2 = tile2->_imagery[layerNum]._imagery->_image.get(); 
     659        if (!(tile2->_imagery[layerNum]._imageDestination.valid())) continue; 
     660     
     661 
     662        osg::Image* image1 = _imagery[layerNum]._imageDestination->_image.get(); 
     663        osg::Image* image2 = tile2->_imagery[layerNum]._imageDestination->_image.get(); 
    664664 
    665665        //log(osg::INFO,"Equalizing edge "<<edgeString(position)<<" of \t"<<_level<<"\t"<<_tileX<<"\t"<<_tileY 
     
    10431043        ++layerNum) 
    10441044    { 
    1045         if (_imagery[layerNum]._imagery.valid() &&  
    1046             _imagery[layerNum]._imagery->_image.valid()) 
     1045        if (_imagery[layerNum]._imageDestination.valid() &&  
     1046            _imagery[layerNum]._imageDestination->_image.valid()) 
    10471047        { 
    10481048            ++numValidImagerLayers; 
     
    10591059    { 
    10601060        ImageData& imageData = _imagery[layerNum]; 
    1061         if (!imageData._imagery.valid() || !imageData._imagery->_image.valid()) continue; 
     1061        if (!imageData._imageDestination.valid() || !imageData._imageDestination->_image.valid()) continue; 
    10621062         
    1063         osg::Image* image = imageData._imagery->_image.get(); 
     1063        osg::Image* image = imageData._imageDestination->_image.get(); 
    10641064 
    10651065        std::string imageExension(_dataSet->_imageExtension); 
     
    14711471    { 
    14721472        ImageData& imageData = _imagery[layerNum]; 
    1473         if (imageData._imagery.valid() && imageData._imagery->_image.valid()) 
     1473        if (imageData._imageDestination.valid() && imageData._imageDestination->_image.valid()) 
    14741474        {         
    1475             osg::Image* image = imageData._imagery->_image.get(); 
     1475            osg::Image* image = imageData._imageDestination->_image.get(); 
    14761476 
    14771477            osgTerrain::ImageLayer* imageLayer = new osgTerrain::ImageLayer; 
     
    18501850        { 
    18511851            ImageData& imageData = _imagery[layerNum]; 
    1852             if (imageData._imagery.valid() && imageData._imagery->_image.valid())  
     1852            if (imageData._imageDestination.valid() && imageData._imageDestination->_image.valid())  
    18531853            { 
    18541854                geometry->setTexCoordArray(layerNum,&t); 
     
    22282228void DestinationTile::readFrom(Source* source) 
    22292229{ 
     2230    bool optionalLayerSet = _dataSet->isOptionalLayerSet(source->getSetName()); 
     2231    log(osg::NOTICE,"DestinationTile::readFrom(SetName=%s, FileName=%s)",source->getSetName().c_str(), source->getFileName().c_str()); 
     2232    if (optionalLayerSet) log(osg::NOTICE,"  is an optional layer set"); 
     2233 
    22302234    if (source &&  
    22312235        source->intersects(*this) && 
     
    22512255                            for(unsigned int i=0;i<_imagery.size();++i) 
    22522256                            { 
    2253                                 if (_imagery[i]._imagery.valid()) 
     2257                                if (_imagery[i]._imageDestination.valid()) 
    22542258                                { 
    2255                                     data->read(*(_imagery[i]._imagery)); 
     2259                                    data->read(*(_imagery[i]._imageDestination)); 
    22562260                                } 
    22572261                            } 
     
    22602264                        { 
    22612265                            // copy specific layer. 
    2262                             if (layerNum<_imagery.size() && _imagery[layerNum]._imagery.valid()) 
     2266                            if (layerNum<_imagery.size() && _imagery[layerNum]._imageDestination.valid()) 
    22632267                            { 
    2264                                 data->read(*(_imagery[layerNum]._imagery)); 
     2268                                data->read(*(_imagery[layerNum]._imageDestination)); 
    22652269                            } 
    22662270                        } 
     
    22722276                        for(unsigned int i=layerNum;i<_imagery.size();++i) 
    22732277                        { 
    2274                             if (_imagery[i]._imagery.valid()) 
     2278                            if (_imagery[i]._imageDestination.valid()) 
    22752279                            { 
    2276                                 data->read(*(_imagery[i]._imagery)); 
     2280                                data->read(*(_imagery[i]._imageDestination)); 
    22772281                            } 
    22782282                        } 
     
    22812285                    case(BuildOptions::NO_INHERITANCE): 
    22822286                    { 
    2283                         if (layerNum<_imagery.size() && _imagery[layerNum]._imagery.valid()) 
     2287                        if (layerNum<_imagery.size() && _imagery[layerNum]._imageDestination.valid()) 
    22842288                        { 
    2285                             data->read(*(_imagery[layerNum]._imagery)); 
     2289                            data->read(*(_imagery[layerNum]._imageDestination)); 
    22862290                        } 
    22872291                        break;