void PipelineReaderJSON::readPipeline(std::istream& input)
{
Json::Value root;
Json::CharReaderBuilder builder;
builder["rejectDupKeys"] = true;
std::string err;
if (!parseFromStream(builder, input, &root, &err))
{
err = "JSON pipeline: Unable to parse pipeline:\n" + err;
throw pdal_error(err);
}
if (root.isObject() && root.isMember("pipeline"))
{
parsePipeline(root["pipeline"]);
}
else if (root.isArray())
{
parsePipeline(root);
}
else
{
throw pdal_error("JSON pipeline: Root element is not a Pipeline");
}
}
void analyseLwo(const std::string& filename, bool modify)
{
std::cout << "--- " << filename << " ---" << std::endl;
std::ifstream istream(filename.c_str(), std::ios::binary);
std::vector<char> vectorBuffer((std::istreambuf_iterator<char>(istream)), std::istreambuf_iterator<char>());
Chunk form;
form.id = "FORM";
form.size = vectorBuffer.size();
form.chunkSizeBytes = 4;
parseFromStream(vectorBuffer, 0, form);
if (!form.subChunks.empty())
{
dumpChunks(form.subChunks[0]);
}
istream.close();
if (!modify) return;
// Write modified LWO
std::string modFile = filename.substr(0, filename.length() - 4) + "_modified.lwo";
std::ofstream output(modFile.c_str(), std::ios::binary);
if (!form.subChunks.empty())
{
filterFile(form.subChunks[0]);
writeFile(output, form.subChunks[0]);
}
}
bool Parser::parseFile( string filename)
{
ifstream is( filename.c_str(), ios::in);
if ( is.is_open())
return parseFromStream( is);
else
return false;
}
inline Json::Value parse(const std::string& input)
{
Json::CharReaderBuilder builder;
Json::Value json;
std::istringstream ss(input);
std::string errors;
if (input.size())
{
if (!parseFromStream(builder, ss, &json, &errors))
{
throw std::runtime_error("Error during parsing: " + errors);
}
}
return json;
}
bool parseFromStream(
CharReader::Factory const& fact, std::istream& sin,
Value* root, std::string* errs)
{
std::ostringstream ssin;
ssin << sin.rdbuf();
std::string doc = ssin.str();
char const* begin = doc.data();
char const* end = begin + doc.size();
// Note that we do not actually need a null-terminator.
CharReaderPtr const reader(fact.newCharReader());
return reader->parse(begin, end, root, errs);
}
std::istream& operator>>(std::istream& sin, Value& root) {
CharReaderBuilder b;
std::string errs;
bool ok = parseFromStream(b, sin, &root, &errs);
if (!ok) {
fprintf(stderr,
"Error from reader: %s",
errs.c_str());
JSON_FAIL_MESSAGE("reader error");
}
return sin;
}
} // namespace Json
void parseFromStream(CharVector& buffer, int level, Chunk& parsedChunk)
{
VectorBuffer<char> tempBuf(buffer);
std::istream stream(&tempBuf);
if (parsedChunk.id == "SURF")
{
std::string surfName = parseString0(stream);
std::string parentName = parseString0(stream);
addStringToContents(parsedChunk.contents, surfName);
addStringToContents(parsedChunk.contents, parentName);
}
if (parsedChunk.id == "IMAP")
{
std::string ordinal = parseString0(stream);
addStringToContents(parsedChunk.contents, ordinal);
}
while (!stream.eof())
{
// Read header
Chunk chunk;
char id[5];
stream.read(id, 4);
id[4] = '\0';
chunk.id = id;
if (stream.eof()) break;
if (parsedChunk.id == "SURF" || parsedChunk.id == "BLOK" ||
parsedChunk.id == "IMAP" || parsedChunk.id == "TMAP")
{
uint16_t size;
stream.read((char*)&size, 2);
size = reverse(size);
chunk.size = size;
chunk.chunkSizeBytes = 2;
}
else
{
uint32_t size;
stream.read((char*)&size, 4);
size = reverse(size);
chunk.size = size;
chunk.chunkSizeBytes = 4;
}
assert(!stream.fail());
//std::string indent(level * 2, ' ');
//std::cout << indent << id << " with size " << chunk.size << " bytes" << std::endl;
// Check size restrictions
assert(4 + chunk.chunkSizeBytes + chunk.size <= buffer.size());
uint32_t dataSize = chunk.size;
if (chunk.id == "FORM")
{
// LWO doesn't have the correct size?
if (dataSize + 4 + 4 != buffer.size())
{
std::cout << "ERROR: FORM Size Value + 8 Bytes is not the same as the file size." << std::endl;
assert(false);
}
// Read the LWO2 tag
char lwo2[5];
stream.read(lwo2, 4);
lwo2[4] = '\0';
assert(std::string(lwo2) == "LWO2");
chunk.contents.push_back('L');
chunk.contents.push_back('W');
chunk.contents.push_back('O');
chunk.contents.push_back('2');
dataSize -= 4;
}
assert(!stream.fail());
chunk.rawData.resize(dataSize);
stream.read(&chunk.rawData.front(), dataSize);
#if 0
if (chunk.id == "COLR")
{
uint32_t colr1Raw = *((uint32_t*)&chunk.rawData[0]);
colr1Raw = reverse(colr1Raw);
float colr1 = *((float*)&colr1Raw);
std::cout << colr1;
}
#endif
assert(!stream.fail());
// Fill bit if size is odd
if (dataSize % 2 == 1)
{
char temp;
stream.read(&temp, 1);
assert(temp == '\0');
assert(!stream.fail());
}
parsedChunk.subChunks.push_back(chunk);
}
// Try to parse the subchunks
for (Chunk& chunk : parsedChunk.subChunks)
{
if (chunk.id == "FORM" || chunk.id == "SURF" || chunk.id == "BLOK" ||
chunk.id == "IMAP" || chunk.id == "TMAP")
{
parseFromStream(chunk.rawData, level + 1, chunk);
}
}
}
