void cv::write(const std::string& sFilePath, const cv::Mat& _oData, cv::MatArchiveList eArchiveType) {
lvAssert_(!sFilePath.empty() && !_oData.empty(),"output file path and matrix must both be non-empty");
cv::Mat oData = _oData.isContinuous()?_oData:_oData.clone();
if(eArchiveType==MatArchive_FILESTORAGE) {
cv::FileStorage oArchive(sFilePath,cv::FileStorage::WRITE);
lvAssert__(oArchive.isOpened(),"could not open archive at '%s' for writing",sFilePath.c_str());
oArchive << "htag" << lv::getVersionStamp();
oArchive << "date" << lv::getTimeStamp();
oArchive << "matrix" << oData;
}
else if(eArchiveType==MatArchive_PLAINTEXT) {
std::ofstream ssStr(sFilePath);
lvAssert__(ssStr.is_open(),"could not open text file at '%s' for writing",sFilePath.c_str());
ssStr << "htag " << lv::getVersionStamp() << std::endl;
ssStr << "date " << lv::getTimeStamp() << std::endl;
ssStr << "nDataType " << (int32_t)oData.type() << std::endl;
ssStr << "nDataDepth " << (int32_t)oData.depth() << std::endl;
ssStr << "nChannels " << (int32_t)oData.channels() << std::endl;
ssStr << "nElemSize " << (uint64_t)oData.elemSize() << std::endl;
ssStr << "nElemCount " << (uint64_t)oData.total() << std::endl;
ssStr << "nDims " << (int32_t)oData.dims << std::endl;
ssStr << "anSizes";
for(int nDimIdx=0; nDimIdx<oData.dims; ++nDimIdx)
ssStr << " " << (int32_t)oData.size[nDimIdx];
ssStr << std::endl << std::endl;
if(oData.depth()!=CV_64F)
_oData.convertTo(oData,CV_64F);
double* pdData = (double*)oData.data;
for(int nElemIdx=0; nElemIdx<(int)oData.total(); ++nElemIdx) {
ssStr << *pdData++;
for(int nElemPackIdx=1; nElemPackIdx<oData.channels(); ++nElemPackIdx)
ssStr << " " << *pdData++;
if(((nElemIdx+1)%oData.size[oData.dims-1])==0)
ssStr << std::endl;
else
ssStr << " ";
}
lvAssert_(ssStr,"plain text archive write failed");
}
else if(eArchiveType==MatArchive_BINARY) {
std::ofstream ssStr(sFilePath,std::ios::binary);
lvAssert__(ssStr.is_open(),"could not open binary file at '%s' for writing",sFilePath.c_str());
const int32_t nDataType = (int32_t)oData.type();
ssStr.write((const char*)&nDataType,sizeof(nDataType));
const uint64_t nElemSize = (uint64_t)oData.elemSize();
ssStr.write((const char*)&nElemSize,sizeof(nElemSize));
const uint64_t nElemCount = (uint64_t)oData.total();
ssStr.write((const char*)&nElemCount,sizeof(nElemCount));
const int32_t nDims = (int32_t)oData.dims;
ssStr.write((const char*)&nDims,sizeof(nDims));
for(int32_t nDimIdx=0; nDimIdx<nDims; ++nDimIdx) {
const int32_t nDimSize = (int32_t)oData.size[nDimIdx];
ssStr.write((const char*)&nDimSize,sizeof(nDimSize));
}
ssStr.write((const char*)(oData.data),nElemSize*nElemCount);
lvAssert_(ssStr,"binary archive write failed");
}
else
lvError("unrecognized mat archive type flag");
}
void cv::read(const std::string& sFilePath, cv::Mat& oData, cv::MatArchiveList eArchiveType) {
lvAssert_(!sFilePath.empty(),"input file path must be non-empty");
if(eArchiveType==MatArchive_FILESTORAGE) {
cv::FileStorage oArchive(sFilePath,cv::FileStorage::READ);
lvAssert__(oArchive.isOpened(),"could not open archive at '%s' for reading",sFilePath.c_str());
oArchive["matrix"] >> oData;
lvAssert_(!oData.empty(),"could not read valid matrix from storage");
}
PasteUndoCommand::PasteUndoCommand(const KnobGuiPtr& knob,
KnobClipBoardType type,
int fromDimension,
int targetDimension,
const KnobPtr& fromKnob)
: QUndoCommand(0)
, _imp( new PasteUndoCommandPrivate() )
{
_imp->knob = knob;
_imp->type = type;
_imp->fromDimension = fromDimension;
_imp->targetDimension = targetDimension;
_imp->fromKnob = fromKnob;
{
std::ostringstream ss;
{
try {
boost::archive::xml_oarchive oArchive(ss);
_imp->originalSerialization->initialize( knob->getKnob() );
oArchive << boost::serialization::make_nvp("KnobClipboard", *_imp->originalSerialization);
} catch (...) {
assert(false);
}
}
_imp->originalSerialization.reset(new KnobSerialization);
std::string str = ss.str();
{
try {
std::stringstream ss(str);
boost::archive::xml_iarchive iArchive(ss);
iArchive >> boost::serialization::make_nvp("KnobClipboard", *_imp->originalSerialization);
} catch (...) {
assert(false);
}
}
}
assert( _imp->originalSerialization->getKnob() );
assert(knob);
assert( _imp->targetDimension >= -1 && _imp->targetDimension < _imp->knob.lock()->getKnob()->getDimension() );
assert( _imp->fromDimension >= -1 && _imp->fromDimension < _imp->fromKnob->getDimension() );
QString text;
switch (type) {
case eKnobClipBoardTypeCopyAnim:
text = tr("Paste Animation to %1");
break;
case eKnobClipBoardTypeCopyValue:
text = tr("Paste Value to %1");
break;
case eKnobClipBoardTypeCopyLink:
text = tr("Paste Link to %1");
break;
}
setText( text.arg( QString::fromUtf8( knob->getKnob()->getLabel().c_str() ) ) );
}
void
Gui::exportLayout()
{
std::vector<std::string> filters;
filters.push_back(NATRON_LAYOUT_FILE_EXT);
SequenceFileDialog dialog( this, filters, false, SequenceFileDialog::eFileDialogModeSave, _imp->_lastSaveProjectOpenedDir.toStdString(), this, false );
if ( dialog.exec() ) {
std::string filename = dialog.filesToSave();
QString filenameCpy( QString::fromUtf8( filename.c_str() ) );
QString ext = QtCompat::removeFileExtension(filenameCpy);
if ( ext != QString::fromUtf8(NATRON_LAYOUT_FILE_EXT) ) {
filename.append("." NATRON_LAYOUT_FILE_EXT);
}
FStreamsSupport::ofstream ofile;
FStreamsSupport::open(&ofile, filename);
if (!ofile) {
Dialogs::errorDialog( tr("Error").toStdString()
, tr("Failed to open file ").toStdString() + filename, false );
return;
}
try {
boost::archive::xml_oarchive oArchive(ofile);
GuiLayoutSerialization s;
s.initialize(this);
oArchive << boost::serialization::make_nvp("Layout", s);
}catch (...) {
Dialogs::errorDialog( tr("Error").toStdString()
, tr("Failed to save the layout").toStdString(), false );
return;
}
}
}