int TranslateKernel::execute()
{
std::ostream *metaOut(nullptr);
if (m_metadataFile.size())
{
metaOut = FileUtils::createFile(m_metadataFile);
if (! metaOut)
throw pdal_error("Couldn't output metadata output file '" +
m_metadataFile + "'.");
}
if (m_filterJSON.size() && m_filterType.size())
throw pdal_error("Cannot set both --filter options and --json options");
if (!m_filterJSON.empty())
makeJSONPipeline();
else
makeArgPipeline();
if (m_pipelineOutput.size() > 0)
PipelineWriter::writePipeline(m_manager.getStage(), m_pipelineOutput);
m_manager.execute();
if (metaOut)
{
MetadataNode m = m_manager.getMetadata();
*metaOut << Utils::toJSON(m);
FileUtils::closeFile(metaOut);
}
return 0;
}
int TranslateKernel::execute()
{
std::ostream *metaOut(nullptr);
if (m_filterJSON.size() && m_filterType.size())
throw pdal_error("Cannot set both --filter options and --json options");
if (m_metadataFile.size())
{
if (m_pipelineOutputFile.size())
m_log->get(LogLevel::Info) << "Metadata will not be written. "
"'pipeline' option prevents execution.";
else
{
metaOut = FileUtils::createFile(m_metadataFile);
if (! metaOut)
throw pdal_error("Couldn't output metadata output file '" +
m_metadataFile + "'.");
}
}
if (!m_filterJSON.empty())
makeJSONPipeline();
else
makeArgPipeline();
// If we write pipeline output, we don't run, and therefore don't write
if (m_pipelineOutputFile.size() > 0)
{
PipelineWriter::writePipeline(m_manager.getStage(),
m_pipelineOutputFile);
return 0;
}
m_manager.execute();
if (metaOut)
{
MetadataNode m = m_manager.getMetadata();
*metaOut << Utils::toJSON(m);
FileUtils::closeFile(metaOut);
}
return 0;
}
void CreatePreviewTask::run()
{
PTOType data(ptoData);
if (data.images.size() != preProcessedUrlsMap.size())
{
errString = i18n("Project file parsing failed.");
kDebug() << "Missing parsing data!";
successFlag = false;
return;
}
KPMetadata metaIn(preProcessedUrlsMap.begin().value().preprocessedUrl.toLocalFile());
KPMetadata metaOut(preProcessedUrlsMap.begin().value().previewUrl.toLocalFile());
double scalingFactor = ((double) metaOut.getPixelSize().width()) / ((double) metaIn.getPixelSize().width());
data.project.fileFormat.fileType = PTOType::Project::FileFormat::JPEG;
data.project.fileFormat.quality = 90;
data.project.size.setHeight(data.project.size.height() * scalingFactor);
data.project.size.setWidth(data.project.size.width() * scalingFactor);
data.project.crop = QRect();
for (int imageId = 0; imageId < data.images.size(); imageId++)
{
PTOType::Image& image = data.images[imageId];
KUrl imgUrl(KUrl(tmpDir), image.fileName);
ItemUrlsMap::const_iterator it;
const ItemUrlsMap* ppum = &preProcessedUrlsMap;
for (it = ppum->constBegin(); it != ppum->constEnd() && it.value().preprocessedUrl != imgUrl; ++it);
if (it == ppum->constEnd())
{
errString = i18n("Unknown input file in the project file: %1", image.fileName);
kDebug() << "Unknown input File in the PTO: " << image.fileName;
kDebug() << "IMG: " << imgUrl.toLocalFile();
successFlag = false;
return;
}
image.fileName = it.value().previewUrl.fileName();
KUrl preview(KUrl(tmpDir), image.fileName);
KPMetadata metaImage(preview.toLocalFile());
image.size = metaImage.getPixelSize();
image.optimisationParameters.clear();
}
// Remove unncessary stuff
data.controlPoints.clear();
// Add two commented line for a JPEG output
data.lastComments.clear();
data.lastComments << "#hugin_outputImageType jpg";
data.lastComments << "#hugin_outputJPEGQuality 90";
(*previewPtoUrl) = tmpDir;
previewPtoUrl->setFileName("preview.pto");
data.createFile(previewPtoUrl->toLocalFile());
kDebug() << "Preview PTO File created: " << previewPtoUrl->fileName();
successFlag = true;
}
int fagzToCompact4(libmaus2::util::ArgInfo const & arginfo)
{
bool const rc = arginfo.getValue<unsigned int>("rc",1);
bool const gz = arginfo.getValue<unsigned int>("gz",1);
std::vector<std::string> inputfilenames;
inputfilenames = arginfo.restargs;
if ( arginfo.hasArg("inputfilenames") )
{
std::string const inf = arginfo.getUnparsedValue("inputfilenames",std::string());
libmaus2::aio::InputStream::unique_ptr_type Pinf(libmaus2::aio::InputStreamFactoryContainer::constructUnique(inf));
while ( *Pinf )
{
std::string line;
std::getline(*Pinf,line);
if ( line.size() )
inputfilenames.push_back(line);
}
}
std::string const inlcp = libmaus2::util::OutputFileNameTools::lcp(inputfilenames);
std::string defout = inlcp;
defout = libmaus2::util::OutputFileNameTools::clipOff(defout,".gz");
defout = libmaus2::util::OutputFileNameTools::clipOff(defout,".fasta");
defout = libmaus2::util::OutputFileNameTools::clipOff(defout,".fa");
std::string const outputfilename = arginfo.getUnparsedValue("outputfilename",defout + ".compact");
std::string const metaoutputfilename = outputfilename + ".meta";
int const verbose = arginfo.getValue<int>("verbose",1);
libmaus2::autoarray::AutoArray<char> B(8*1024,false);
libmaus2::bitio::CompactArrayWriterFile compactout(outputfilename,2 /* bits per symbol */);
if ( ! rc )
std::cerr << "[V] not storing reverse complements" << std::endl;
// forward mapping table
libmaus2::autoarray::AutoArray<uint8_t> ftable(256,false);
// rc mapping for mapped symbols
libmaus2::autoarray::AutoArray<uint8_t> ctable(256,false);
std::fill(ftable.begin(),ftable.end(),4);
std::fill(ctable.begin(),ctable.end(),4);
ftable['a'] = ftable['A'] = 0;
ftable['c'] = ftable['C'] = 1;
ftable['g'] = ftable['G'] = 2;
ftable['t'] = ftable['T'] = 3;
uint64_t insize = 0;
ctable[0] = 3; // A->T
ctable[1] = 2; // C->G
ctable[2] = 1; // G->C
ctable[3] = 0; // T->A
libmaus2::aio::OutputStreamInstance::unique_ptr_type metaOut(new libmaus2::aio::OutputStreamInstance(metaoutputfilename));
libmaus2::util::NumberSerialisation::serialiseNumber(*metaOut,0);
uint64_t nseq = 0;
std::vector<uint64_t> lvec;
for ( uint64_t i = 0; i < inputfilenames.size(); ++i )
{
std::string const fn = inputfilenames[i];
libmaus2::aio::InputStreamInstance CIS(fn);
libmaus2::lz::BufferedGzipStream::unique_ptr_type BGS;
std::istream * istr = 0;
if ( gz )
{
libmaus2::lz::BufferedGzipStream::unique_ptr_type tBGS(
new libmaus2::lz::BufferedGzipStream(CIS));
BGS = UNIQUE_PTR_MOVE(tBGS);
istr = BGS.get();
}
else
{
istr = &CIS;
}
libmaus2::fastx::StreamFastAReaderWrapper fain(*istr);
libmaus2::fastx::StreamFastAReaderWrapper::pattern_type pattern;
while ( fain.getNextPatternUnlocked(pattern) )
{
if ( verbose )
std::cerr << (i+1) << " " << stripAfterDot(basename(fn)) << " " << pattern.sid << "...";
libmaus2::util::NumberSerialisation::serialiseNumber(*metaOut,pattern.spattern.size());
lvec.push_back(pattern.spattern.size());
libmaus2::util::NumberSerialisation::serialiseNumber(*metaOut,0);
// map symbols
for ( uint64_t j = 0; j < pattern.spattern.size(); ++j )
pattern.spattern[j] = ftable[static_cast<uint8_t>(pattern.spattern[j])];
// replace blocks of N symbols by random bases
uint64_t l = 0;
// number of replaced blocks
uint64_t nr = 0;
while ( l < pattern.spattern.size() )
{
// skip regular bases
while ( l < pattern.spattern.size() && pattern.spattern[l] < 4 )
++l;
assert ( l == pattern.spattern.size() || pattern.spattern[l] == 4 );
// go to end of non regular bases block
uint64_t h = l;
while ( h < pattern.spattern.size() && pattern.spattern[h] == 4 )
++h;
// if non regular block is not empty
if ( h-l )
{
// replace by random bases
for ( uint64_t j = l; j < h; ++j )
pattern.spattern[j] = (libmaus2::random::Random::rand8() & 3);
// write bounds
libmaus2::util::NumberSerialisation::serialiseNumber(*metaOut,l);
libmaus2::util::NumberSerialisation::serialiseNumber(*metaOut,h);
// add to interval counter
nr += 1;
}
l = h;
}
// make sure there are no more irregular bases
for ( uint64_t j = 0; j < pattern.spattern.size(); ++j )
assert ( pattern.spattern[j] < 4 );
// go back to start of meta data
metaOut->seekp( - static_cast<int64_t>(2*nr+1)*sizeof(uint64_t), std::ios::cur );
// write number of intervals replaced
libmaus2::util::NumberSerialisation::serialiseNumber(*metaOut,nr);
// skip interval bounds already written
metaOut->seekp( static_cast<int64_t>(2*nr )*sizeof(uint64_t), std::ios::cur );
// write bases
compactout.write(pattern.spattern.c_str(),pattern.spattern.size());
// write reverse complement if requested
if ( rc )
{
// reverse complement
std::reverse(pattern.spattern.begin(),pattern.spattern.end());
for ( uint64_t j = 0; j < pattern.spattern.size(); ++j )
pattern.spattern[j] = ctable[static_cast<uint8_t>(pattern.spattern[j])];
// write
compactout.write(pattern.spattern.c_str(),pattern.spattern.size());
}
insize += pattern.spattern.size()+1;
nseq += 1;
if ( verbose )
std::cerr << "done, input size " << formatBytes(pattern.spattern.size()+1) << " acc " << formatBytes(insize) << std::endl;
}
}
metaOut->seekp(0);
libmaus2::util::NumberSerialisation::serialiseNumber(*metaOut,nseq);
metaOut->flush();
metaOut.reset();
libmaus2::aio::InputStreamInstance::unique_ptr_type metaISI(new libmaus2::aio::InputStreamInstance(metaoutputfilename));
// number of sequences
uint64_t const rnseq = libmaus2::util::NumberSerialisation::deserialiseNumber(*metaISI);
assert ( nseq == rnseq );
for ( uint64_t i = 0; i < nseq; ++i )
{
// length of sequence
uint64_t const l = libmaus2::util::NumberSerialisation::deserialiseNumber(*metaISI);
assert ( l == lvec[i] );
uint64_t const nr = libmaus2::util::NumberSerialisation::deserialiseNumber(*metaISI);
// skip replaced intervals
metaISI->ignore(2*nr*sizeof(uint64_t));
}
assert ( metaISI->peek() == std::istream::traits_type::eof() );
std::cerr << "Done, total input size " << insize << std::endl;
compactout.flush();
return EXIT_SUCCESS;
}