mirror of
https://github.com/OPM/ResInsight.git
synced 2025-02-04 12:40:58 -06:00
326 lines
9.8 KiB
C++
326 lines
9.8 KiB
C++
// $Id: surfaceio.cpp 882 2011-09-23 13:10:16Z perroe $
|
|
|
|
// Copyright (c) 2011, Norwegian Computing Center
|
|
// All rights reserved.
|
|
// Redistribution and use in source and binary forms, with or without modification,
|
|
// are permitted provided that the following conditions are met:
|
|
// • Redistributions of source code must retain the above copyright notice, this
|
|
// list of conditions and the following disclaimer.
|
|
// • Redistributions in binary form must reproduce the above copyright notice, this list of
|
|
// conditions and the following disclaimer in the documentation and/or other materials
|
|
// provided with the distribution.
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
|
|
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
|
|
// SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
|
|
// OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
|
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
|
|
// EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
#include <cmath>
|
|
#include <fstream>
|
|
#include <string>
|
|
|
|
#include "surfaceio.hpp"
|
|
|
|
#include "regularsurface.hpp"
|
|
#include "regularsurfacerotated.hpp"
|
|
#include "surface.hpp"
|
|
#include "../exception/exception.hpp"
|
|
#include "../iotools/fileio.hpp"
|
|
#include "../iotools/stringtools.hpp"
|
|
|
|
namespace NRLib {
|
|
|
|
//const double IRAP_MISSING = 9999900.0;
|
|
//const double STORM_MISSING = -999.0;
|
|
|
|
|
|
namespace NRLibPrivate {
|
|
/// \todo Move to a suitable place
|
|
bool Equal(double a, double b)
|
|
{
|
|
if ( fabs(a-b) <= 0.0001 * a ) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
} // namespace NRLibPrivate
|
|
|
|
SurfaceFileFormat FindSurfaceFileType(const std::string& filename)
|
|
{
|
|
std::ifstream file;
|
|
OpenRead(file, filename, std::ios::in | std::ios::binary);
|
|
|
|
std::string first_token;
|
|
if (!(file >> first_token)) {
|
|
// Empty file.
|
|
return SURF_UNKNOWN;
|
|
}
|
|
|
|
if (first_token == "-996")
|
|
return SURF_IRAP_CLASSIC_ASCII;
|
|
else if (first_token == "STORMGRID_BINARY")
|
|
return SURF_STORM_BINARY;
|
|
else if (first_token == "NORSAR") {
|
|
std::string token;
|
|
file >> token;
|
|
file >> token;
|
|
file >> token;
|
|
file >> token;
|
|
if(token == "v1.0" ||token == "v2.0" )
|
|
return SURF_SGRI;
|
|
}
|
|
else if (IsType<double>(first_token)) {
|
|
file.seekg(0, std::ios_base::beg);
|
|
std::string line;
|
|
std::getline(file, line);
|
|
std::vector<std::string> tokens = GetTokens(line);
|
|
if (tokens.size() == 3) {
|
|
// Check last line of file.
|
|
file.seekg(0, std::ios_base::end);
|
|
std::streampos file_len = file.tellg();
|
|
std::streampos offset = std::min(static_cast<std::streampos>(50), file_len);
|
|
file.seekg(-offset, std::ios_base::end);
|
|
|
|
tokens.clear();
|
|
|
|
while (std::getline(file, line)) {
|
|
if (GetTokens(line).size() > 0) {
|
|
tokens = GetTokens(line);
|
|
}
|
|
}
|
|
|
|
if (tokens.size() == 3) {
|
|
try {
|
|
if (ParseType<double>(tokens[0]) == 999.0 &&
|
|
ParseType<double>(tokens[1]) == 999.0 &&
|
|
ParseType<double>(tokens[2]) == 999.0) {
|
|
return SURF_RMS_POINTS_ASCII;
|
|
}
|
|
}
|
|
catch (Exception& ) {
|
|
// Do nothing - failed to parse tokens as doubles.
|
|
}
|
|
}
|
|
}
|
|
return SURF_UNKNOWN;
|
|
}
|
|
|
|
//Try multicolum ascii
|
|
int dummy;
|
|
bool is_multicolumn_ascii = FindMulticolumnAsciiLine(filename, dummy);
|
|
|
|
if (is_multicolumn_ascii == true)
|
|
return SURF_MULT_ASCII;
|
|
|
|
return SURF_UNKNOWN;
|
|
}
|
|
|
|
|
|
std::string GetSurfFormatString(NRLib::SurfaceFileFormat format)
|
|
{
|
|
switch (format) {
|
|
case SURF_UNKNOWN:
|
|
return "Unknown surface format";
|
|
case SURF_IRAP_CLASSIC_ASCII:
|
|
return "IRAP classic ASCII";
|
|
case SURF_STORM_BINARY:
|
|
return "Storm binary";
|
|
case SURF_SGRI:
|
|
return "NORSAR SGRI";
|
|
case SURF_RMS_POINTS_ASCII:
|
|
return "RMS XYZ point set surface";
|
|
case SURF_MULT_ASCII:
|
|
return "Multicolumn ASCII";
|
|
default:
|
|
throw Exception("Missing format description for format: " + ToString(format));
|
|
}
|
|
}
|
|
|
|
|
|
std::vector<RegularSurfaceRotated<float> >
|
|
ReadMultipleSgriSurf(const std::string& filename, const std::vector<std::string> & labels)
|
|
{
|
|
std::ifstream header_file;
|
|
OpenRead(header_file, filename.c_str(), std::ios::in | std::ios::binary);
|
|
int i, dim;
|
|
std::string tmp_str;
|
|
try {
|
|
//Reading record 1: Version header
|
|
getline(header_file, tmp_str);
|
|
//Reading record 2: Grid dimension
|
|
header_file >> dim;
|
|
if(dim!=2)
|
|
throw Exception("Wrong dimension of Sgri file. We expect a surface, dimension should be 2.\n");
|
|
|
|
getline(header_file, tmp_str);
|
|
//Reading record 3 ... 3+dim: Axis labels + grid value label
|
|
std::vector<std::string> axis_labels(dim);
|
|
std::string err_txt;
|
|
for (i=0; i<dim; i++) {
|
|
getline(header_file, axis_labels[i]);
|
|
if(labels.size() > static_cast<size_t>(i)) {
|
|
NRLib::Uppercase(axis_labels[i]);
|
|
NRLib::Uppercase(labels[i]);
|
|
if (axis_labels[i].find(labels[i]) == std::string::npos)
|
|
err_txt += "Wrong axis labels. Label for axis "+NRLib::ToString(i)+" should be '"+labels[i]+"'.\n";
|
|
}
|
|
}
|
|
getline(header_file, tmp_str);
|
|
|
|
//Reading record 4+dim: Number of grids
|
|
int n_grid;
|
|
header_file >> n_grid;
|
|
if (n_grid < 1) {
|
|
throw Exception("Error: Number of grids read from sgri file must be > 0");
|
|
}
|
|
getline(header_file, tmp_str);
|
|
|
|
//Reading record 5+dim ... 5+dim+ngrid-1: Grid labels
|
|
for (i=0; i<n_grid; i++)
|
|
getline(header_file, tmp_str);
|
|
|
|
std::vector<float> d_values1(dim);
|
|
std::vector<float> d_values2(dim);
|
|
std::vector<int> i_values(dim);
|
|
//Reading record 5+dim+ngrid: Scaling factor of grid values
|
|
for (i=0; i<dim; i++)
|
|
header_file >> d_values1[i];
|
|
getline(header_file,tmp_str);
|
|
//Reading record 6+dim+ngrid: Number of samples in each dir.
|
|
for (i=0; i<dim; i++)
|
|
header_file >> i_values[i];
|
|
getline(header_file,tmp_str);
|
|
//Reading record 7+dim+ngrid: Grid sampling in each dir.
|
|
for (i=0; i<dim; i++)
|
|
header_file >> d_values2[i];
|
|
|
|
getline(header_file,tmp_str);
|
|
//Reading record 8+dim+ngrid: First point coord.
|
|
std::vector<float> min_values(dim);
|
|
for (i=0; i<dim; i++)
|
|
header_file >> min_values[i];
|
|
|
|
int nx=1;
|
|
int ny=1;
|
|
double dx, dy;
|
|
nx = i_values[0];
|
|
dx = d_values2[0];
|
|
ny = i_values[1];
|
|
dy = d_values2[1];
|
|
|
|
if (nx < 1)
|
|
throw Exception("Error: Number of samples on first axis must be >= 1.\n");
|
|
if (ny < 1)
|
|
throw Exception("Error: Number of samples on second axis must be >= 1.\n");
|
|
|
|
if (dx <= 0.0)
|
|
throw Exception("Error: Grid sampling on first axis must be > 0.0.\n");
|
|
if (dy <= 0.0)
|
|
throw Exception("Error: Grid sampling on second axis must be > 0.0.\n");
|
|
|
|
double lx = (nx-1)*dx;
|
|
double ly = (ny-1)*dy;
|
|
|
|
double x_min = min_values[0]-0.5*dx;
|
|
double y_min = min_values[1]-0.5*dy;
|
|
|
|
double angle;
|
|
header_file >> angle;
|
|
|
|
getline(header_file, tmp_str);
|
|
//Reading record 10+dim+ngrid: Undef value
|
|
float missing_code;
|
|
header_file >> missing_code;
|
|
|
|
getline(header_file, tmp_str);
|
|
//Reading record 11+dim+ngrid: Filename of binary file
|
|
std::string bin_file_name;
|
|
getline(header_file, tmp_str);
|
|
if (!tmp_str.empty()) {
|
|
std::locale loc;
|
|
int i = 0;
|
|
char c = tmp_str[i];
|
|
while (!std::isspace(c,loc)) {
|
|
i++;
|
|
c = tmp_str[i];
|
|
}
|
|
tmp_str.erase(tmp_str.begin()+i, tmp_str.end());
|
|
}
|
|
if (tmp_str.empty())
|
|
bin_file_name = NRLib::ReplaceExtension(filename, "Sgri");
|
|
else {
|
|
std::string path = GetPath(filename);
|
|
bin_file_name = path + "/" + tmp_str;
|
|
}
|
|
//Reading record 12+dim+ngrid: Complex values
|
|
bool has_complex;
|
|
header_file >> has_complex;
|
|
if (has_complex != 0 ) {
|
|
throw Exception("Error: Can not read Sgri binary file. Complex values?");
|
|
}
|
|
|
|
std::vector<RegularSurfaceRotated<float> > surfaces(n_grid);
|
|
std::ifstream bin_file;
|
|
OpenRead(bin_file, bin_file_name.c_str(), std::ios::in | std::ios::binary);
|
|
for (i=0; i<n_grid; i++) {
|
|
surfaces[i] = RegularSurfaceRotated<float>(x_min,y_min,lx,ly,nx,ny,angle,0.0f);
|
|
surfaces[i].SetMissingValue(missing_code);
|
|
ReadBinaryFloatArray(bin_file, surfaces[i].begin(), surfaces[i].GetN());
|
|
}
|
|
|
|
return surfaces;
|
|
}
|
|
catch (Exception& e) {
|
|
throw FileFormatError("Error parsing \"" + filename + "\" as a "
|
|
"Sgri surface file " + e.what() + "\n");
|
|
}
|
|
}
|
|
|
|
bool FindMulticolumnAsciiLine(const std::string& filename, int & header_start_line)
|
|
{
|
|
//Contains five columns: X, Y, IL, CL, Attribute
|
|
//File starts with several information lines
|
|
std::ifstream file;
|
|
NRLib::OpenRead(file, filename);
|
|
int line = 0;
|
|
|
|
//Find first line with five numbers
|
|
bool found_mult_ascii_line = false;
|
|
while (found_mult_ascii_line == false) {
|
|
|
|
//Read line
|
|
std::string line_string;
|
|
std::getline(file, line_string);
|
|
std::vector<std::string> tokens = NRLib::GetTokens(line_string);
|
|
|
|
//Check if the line has five number elements
|
|
if (tokens.size() == 5) {
|
|
for (int i = 0; i < 5; i++) {
|
|
if (!NRLib::IsNumber(tokens[i])) {
|
|
found_mult_ascii_line = false;
|
|
break;
|
|
}
|
|
else
|
|
found_mult_ascii_line = true;
|
|
}
|
|
}
|
|
|
|
line++;
|
|
}
|
|
file.close();
|
|
|
|
header_start_line = line -2;
|
|
|
|
return found_mult_ascii_line;
|
|
}
|
|
|
|
|
|
//void WritePointAsciiSurf(const RegularSurface<double>& surf,
|
|
// const std::string& filename);
|
|
|
|
} // namespace NRLib
|