Ignore:
Timestamp:
07/04/11 07:48:20 (10 years ago)
Author:
hozdoba
Message:
 
File:
1 edited

Legend:

Unmodified
Added
Removed
  • XMLIO_V2/dev/dev_rv/src4/xmlio/vtk/lscereader.cpp

    r239 r241  
    6262      vtkLSCEReader::vtkLSCEReader(void) 
    6363         : FileName(), CurGridType(RECTILINEAR), VarNames() 
    64          , A3D(true), ATemporal(true), ACell(true) 
     64         , A3D(true), ATemporal(true), ACell(true), AGridDef(false) 
    6565         , Reader() 
    6666      { 
     
    187187                            vtkInformationVector *  outputVector) 
    188188      { 
     189         try 
     190         { 
    189191           
    190          if(request->Has(vtkDemandDrivenPipeline::REQUEST_DATA())) 
    191          { 
    192             return (this->RequestData(NULL, NULL, outputVector)); 
    193          } 
    194  
    195          if(request->Has(vtkDemandDrivenPipeline::REQUEST_DATA_OBJECT())) 
    196          { 
    197          //   return (this->RequestDataObject(NULL, NULL, outputVector)); 
    198          } 
    199  
    200          if(request->Has(vtkDemandDrivenPipeline::REQUEST_INFORMATION())) 
    201          { 
    202               return (this->RequestInformation(NULL, NULL, outputVector)); 
    203          } 
    204  
    205          if(request->Has(vtkStreamingDemandDrivenPipeline::REQUEST_UPDATE_EXTENT())) 
    206          { 
    207             return (this->RequestUpdateExtent(NULL, NULL, outputVector)); 
    208          } 
    209  
     192            if(request->Has(vtkDemandDrivenPipeline::REQUEST_DATA())) 
     193            { 
     194               return (this->RequestData(NULL, NULL, outputVector)); 
     195            } 
     196 
     197            if(request->Has(vtkDemandDrivenPipeline::REQUEST_DATA_OBJECT())) 
     198            { 
     199            //   return (this->RequestDataObject(NULL, NULL, outputVector)); 
     200            } 
     201 
     202            if(request->Has(vtkDemandDrivenPipeline::REQUEST_INFORMATION())) 
     203            { 
     204                 return (this->RequestInformation(NULL, NULL, outputVector)); 
     205            } 
     206 
     207            if(request->Has(vtkStreamingDemandDrivenPipeline::REQUEST_UPDATE_EXTENT())) 
     208            { 
     209               return (this->RequestUpdateExtent(NULL, NULL, outputVector)); 
     210            } 
     211         } 
     212         catch (xmlioserver::CException & _exception) 
     213         { 
     214            std::cerr << _exception.getMessage() << std::endl; 
     215            return (-1); 
     216         } 
    210217         return (1); 
    211218      } 
     
    484491         } 
    485492      } 
     493 
     494      //---------------------------------------------------------------- 
    486495       
    487496      void vtkLSCEReader::GetDimensions(const vtkStdString & xcoordinate, 
     
    548557         } 
    549558 
    550          dimensions->SetValue(0, dimensions->GetValue(0)+1); 
    551          dimensions->SetValue(1, dimensions->GetValue(1)+1); 
     559         dimensions->SetValue(0, dimensions->GetValue(0) + 1); 
     560         dimensions->SetValue(1, dimensions->GetValue(1) + 1); 
    552561 
    553562         if (Reader->hasBounds(xcoordinate)) 
     
    616625                                            vtkIntArray * dimensions) 
    617626      { 
    618          float  value[3], range[2]; 
     627         float  value[3]; 
    619628         double h = 1.0; 
    620          double cartesianCoord[3], vbounds[6]; 
     629         double cartesianCoord[3], vbounds[6], range[2]; 
    621630         vtkIdType pts[nbvertex] ; 
    622631         bool is2D = true; 
     
    634643            zspacing->InsertNextValue(0); 
    635644          
    636          zspacing->GetValueRange (range); 
     645         zspacing->GetRange (range); 
    637646 
    638647         std::size_t size = (*Reader->getDimensions(&xcoordinate).begin()).second; 
     
    724733         data->SetName(varname.c_str()); 
    725734         ARRAY_CREATE(data_arr, double, 1, [1]); 
    726          Reader->readData(*data_arr, varname); 
     735         Reader->readData(*data_arr, varname, record); 
    727736         Reader->replaceMissingValue(varname, *data_arr, vtkMath::Nan()); 
    728737          
     
    775784         vtkRectilinearGrid  * routput  = vtkRectilinearGrid::SafeDownCast(output); 
    776785         vtkStructuredGrid   * soutput  = vtkStructuredGrid::SafeDownCast(output); 
    777  
     786          
     787        double time = 0.0; 
     788        if (outInfo->Has(vtkStreamingDemandDrivenPipeline::UPDATE_TIME_STEPS())) 
     789           time = outInfo->Get(vtkStreamingDemandDrivenPipeline::UPDATE_TIME_STEPS())[0]; 
     790         
    778791         if (routput && !this->VarNames.empty()) 
    779792         { // Grille rectiliniéaire 
     
    793806            dims->InsertNextValue(yspacing->GetNumberOfTuples()); 
    794807            dims->InsertNextValue(zspacing->GetNumberOfTuples()); 
    795  
     808             
     809            CreateRectilinearGrid(routput, outInfo, xspacing, yspacing, zspacing, dims); 
    796810            AddScalarData(routput, *VarNames.begin(), 0, true); 
    797             CreateRectilinearGrid(routput, outInfo, xspacing, yspacing, zspacing, dims); 
     811 
     812            this->AGridDef = true; 
    798813         } 
    799814 
     
    809824                      Reader->getVertCoordName(*VarNames.begin()), true, true, pts, dims); 
    810825 
     826            CreateStructuredGrid(soutput, outInfo, pts, dims); 
    811827            AddScalarData(soutput, *VarNames.begin(), 0, true); 
    812             CreateStructuredGrid(soutput, outInfo, pts, dims); 
     828 
     829            this->AGridDef = true; 
    813830         } 
    814831 
    815832         if (uoutput  && !this->VarNames.empty()) 
    816833         { // Grille non-structurée 
    817  
    818834            vtkSmartPointer<vtkPoints>    pts   = vtkSmartPointer<vtkPoints>::New(); 
    819835            vtkSmartPointer<vtkIntArray>  dims  = vtkSmartPointer<vtkIntArray>::New(); 
     
    822838            //CreateSimpleGrid (0, 12, 0, 12, 0, 12, pts, cells, dims); 
    823839            //std::cout << Reader->getVertCoordName(*VarNames.begin()) << std::endl; 
    824              
     840 
    825841            GetCellsAndPoints(Reader->getLonCoordName(*VarNames.begin()), 
    826842                              Reader->getLatCoordName(*VarNames.begin()), 
    827                               Reader->getVertCoordName(*VarNames.begin()), true, false, true, 
     843                              Reader->getVertCoordName(*VarNames.begin()), true, true, true, 
    828844                              Reader->getNbVertex(*VarNames.begin()), cells, pts, dims); 
     845 
     846            CreateUnstructuredGrid(uoutput, outInfo, pts, cells, VTK_POLYGON); 
     847          
     848            AddScalarData(uoutput, *VarNames.begin(), this->GetRecord(*VarNames.begin(), time), true); 
    829849             
    830             AddScalarData(uoutput, *VarNames.begin(), 0, true); 
    831             CreateUnstructuredGrid(uoutput, outInfo, pts, cells, VTK_POLYGON); 
    832  
    833  
     850            this->AGridDef = true; 
    834851         } 
    835852         return (1); 
    836853      } 
     854 
     855      //---------------------------------------------------------------- 
     856       
     857      void vtkLSCEReader::GetTimeInformation 
     858               (const vtkStdString & variable, vtkDoubleArray * values, double * timeRange) 
     859      { 
     860         std::string timename = this->Reader->getTimeCoordName(variable); 
     861         if (this->Reader->hasVariable(timename)) 
     862         { 
     863            ARRAY_CREATE(data_arr, double, 1, [1]); 
     864            Reader->readData(*data_arr, timename); 
     865             
     866            values->SetNumberOfValues (data_arr->size()); 
     867            for (std::size_t i = 0; i < data_arr->size(); i++) 
     868               values->SetValue (i, (*data_arr)[i]); 
     869         } 
     870         else 
     871         { 
     872            std::size_t nbtimestep = this->Reader->getNbOfTimestep(); 
     873            values->SetNumberOfValues (nbtimestep); 
     874            for (std::size_t i = 0; i < nbtimestep; i++) 
     875               values->SetValue (i, i); 
     876         } 
     877         timeRange[0] = values->GetValue(0); 
     878         timeRange[1] = values->GetValue(values->GetNumberOfTuples()-1); 
     879      } 
     880       
     881      std::size_t vtkLSCEReader::GetRecord(const vtkStdString & variable, const double & value) 
     882      { 
     883         std::string timename = this->Reader->getTimeCoordName(variable); 
     884         if (this->Reader->hasVariable(timename)) 
     885         { 
     886            ARRAY_CREATE(data_arr, double, 1, [1]); 
     887            Reader->readData(*data_arr, timename); 
     888            return (std::find(data_arr->begin(), data_arr->end(), value) - data_arr->begin()); 
     889         } 
     890         else 
     891         { 
     892            return (value); 
     893         } 
     894      } 
     895 
     896      //---------------------------------------------------------------- 
    837897       
    838898      int vtkLSCEReader::RequestInformation 
     
    844904         vtkDataSet     *  output  = vtkDataSet::GetData(outInfo); 
    845905 
    846          if (true) 
     906         this->AGridDef = false; 
     907          
     908         if (!this->VarNames.empty()) 
    847909         { 
    848910            switch (this->CurGridType) 
     
    864926         vtkRectilinearGrid  * routput  = vtkRectilinearGrid::SafeDownCast(output); 
    865927         vtkStructuredGrid   * soutput  = vtkStructuredGrid::SafeDownCast(output); 
     928          
     929         if (!this->VarNames.empty()) 
     930         { // Informations temporelles 
     931            if (this->Reader->hasTemporalDim() && this->Reader->isTemporal(*VarNames.begin())) 
     932            { 
     933               vtkSmartPointer<vtkDoubleArray> timeStepValues = vtkSmartPointer<vtkDoubleArray>::New(); 
     934               double timeRange[2]; 
     935               this->GetTimeInformation(*VarNames.begin(), timeStepValues, timeRange); 
     936 
     937               outInfo->Set(vtkStreamingDemandDrivenPipeline::TIME_STEPS(), 
     938                            timeStepValues->GetPointer(0), 
     939                            timeStepValues->GetNumberOfTuples()); 
     940               outInfo->Set(vtkStreamingDemandDrivenPipeline::TIME_RANGE(), timeRange, 2); 
     941            } 
     942            else 
     943            { 
     944               outInfo->Remove(vtkStreamingDemandDrivenPipeline::TIME_STEPS()); 
     945               outInfo->Remove(vtkStreamingDemandDrivenPipeline::TIME_RANGE()); 
     946            } 
     947             
     948         } 
    866949          
    867950         if (routput && !this->VarNames.empty()) 
Note: See TracChangeset for help on using the changeset viewer.