razzaline/tahoma2d
1
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity
tahoma2d/toonz/sources/tconverter/tconverter.cpp
Shinya Kitaoka 9eb50de5fe Use std functions (#297) 
* use std functions

* replace toInt        to std::stoi
* replace toDouble     to std::stod
* replace toString     to std::to_string
* replace toWideString to std::to_wstring

* fix for MacOS

* cosmetic change
2016-06-07 16:06:00 +09:00

453 lines
14 KiB
C++
Raw Blame History

// TnzLib includes
#include "toonz/toonzscene.h"
#include "toonz/preferences.h"
#include "toonz/sceneproperties.h"
#include "toutputproperties.h"
// TnzBase includes
#include "tcli.h"
#include "tenv.h"
#include "tpluginmanager.h"
#include "trasterfx.h"
// TnzCore includes
#include "tsystem.h"
#include "tstream.h"
#include "tfilepath_io.h"
#include "tconvert.h"
#include "tiio_std.h"
#include "timage_io.h"
#include "tnzimage.h"
#include "tlevel.h"
#include "tlevel_io.h"
#include "tpalette.h"
#include "tropcm.h"
#include "trasterimage.h"
#include "tvectorimage.h"
#include "tvectorrenderdata.h"
#include "tofflinegl.h"
using namespace std;
using namespace TCli;
typedef ArgumentT<TFilePath> FilePathArgument;
typedef QualifierT<TFilePath> FilePathQualifier;
#define RENDER_LICENSE_NOT_FOUND 888
const char *applicationVersion = "1.0";
const char *applicationName = "OpenToonz";
const char *rootVarName = "TOONZROOT";
const char *systemVarPrefix = "TOONZ";
namespace
{
//--------------------------------------------------------------------
void doesExist(const TFilePath &fp)
{
string msg;
TFilePath path = fp.getParentDir() + (fp.getName() + "." + fp.getDottedType());
if (TSystem::doesExistFileOrLevel(fp) || TSystem::doesExistFileOrLevel(path)) {
msg = "File " + fp.getLevelName() + " already exists:";
cout << endl
<< msg << endl;
char answer = ' ';
while (answer != 'Y' && answer != 'N' && answer != 'y' && answer != 'n') {
msg = "do you want to replace it? [Y/N] ";
cout << msg;
cin >> answer;
if (answer == 'N' || answer == 'n') {
msg = "Conversion aborted.";
cout << endl
<< msg << endl;
exit(1);
}
}
}
}
//--------------------------------------------------------------------
//Ritorna un vettore contenete i soli TFrameId corrispondenti al range inserito dall'utente
vector<TFrameId> getFrameIds(const RangeQualifier &range, const TLevelP &level)
{
string msg;
TFrameId r0, r1, lastFrame;
TLevel::Iterator begin = level->begin();
TLevel::Iterator end = level->end();
end--;
lastFrame = end->first;
vector<TFrameId> frames;
if (range.isSelected()) {
r0 = TFrameId(range.getFrom());
r1 = TFrameId(range.getTo());
if (r0 > r1) {
TFrameId app = r0;
r0 = r1;
r1 = app;
}
} else {
r0 = begin->first;
r1 = end->first;
}
//cerco il primo TFrameId
TLevel::Iterator it = begin;
if (r0 <= end->first)
while (it->first < r0)
++it;
while (it != level->end() && r1 >= it->first) {
//Riempio il vettore fino all'ultimo TFrameId che mi serve
frames.push_back(it->first);
++it;
}
return frames;
}
//--------------------------------------------------------------------
void convertFromCM(const TLevelReaderP &lr, const TPaletteP &plt, const TLevelWriterP &lw, const vector<TFrameId> &frames,
const TAffine &aff, const TRop::ResampleFilterType &resType)
{
TDimension dim(0, 0); //Serve per controllare che non ci siano frame di diverse dimensioni
for (int i = 0; i < (int)frames.size(); i++) {
try {
TImageReaderP ir = lr->getFrameReader(frames[i]);
TImageP img = ir->load();
TToonzImageP toonzImage(img);
double xdpi, ydpi;
toonzImage->getDpi(xdpi, ydpi);
assert(toonzImage);
if (toonzImage) {
TRasterCM32P rasCMImage = toonzImage->getRaster();
if (i == 0)
dim = rasCMImage->getSize();
else if (dim != rasCMImage->getSize()) {
//dimensioni diverse dei frame
string msg = "Cannot continue to convert: not valid level!";
cout << msg << endl;
exit(1);
}
TRaster32P ras(convert(aff * convert(rasCMImage->getBounds())).getSize());
if (!aff.isIdentity())
TRop::resample(ras, rasCMImage, plt, aff, resType);
else
TRop::convert(ras, rasCMImage, plt);
TRasterImageP rasImage(ras);
rasImage->setDpi(xdpi, ydpi);
TImageWriterP iw = lw->getFrameWriter(frames[i]);
iw->save(rasImage);
}
} catch (...) {
string msg = "Frame " + std::to_string(frames[i].getNumber()) + ": conversion failed!";
cout << msg << endl;
}
}
}
//--------------------------------------------------------------------
void convertFromVI(const TLevelReaderP &lr, const TPaletteP &plt, const TLevelWriterP &lw, const vector<TFrameId> &frames,
const TRop::ResampleFilterType &resType, int width)
{
int i;
vector<TVectorImageP> images;
TRectD maxBbox;
TAffine aff;
for (i = 0; i < (int)frames.size(); i++) { //trovo la bbox che possa contenere tutte le immagini
try {
TImageReaderP ir = lr->getFrameReader(frames[i]);
TVectorImageP img = ir->load();
images.push_back(img);
maxBbox += img->getBBox();
} catch (...) {
string msg = "Frame " + std::to_string(frames[i].getNumber()) + ": conversion failed!";
cout << msg << endl;
}
}
maxBbox = maxBbox.enlarge(2);
if (width) //calcolo l'affine
aff = TScale((double)width / maxBbox.getLx());
maxBbox = aff * maxBbox;
for (i = 0; i < (int)images.size(); i++) {
try {
TVectorImageP vectorImage = images[i];
assert(vectorImage);
if (vectorImage) {
//faccio il render dell'immagine
vectorImage->transform(aff, true);
const TVectorRenderData rd(TTranslation(-maxBbox.getP00()), TRect(), plt.getPointer(), 0, true, true);
TOfflineGL *glContext = new TOfflineGL(convert(maxBbox).getSize());
glContext->clear(TPixel32::Transparent);
glContext->draw(vectorImage, rd);
TRaster32P rasImage = (glContext->getRaster());
TImageWriterP iw = lw->getFrameWriter(frames[i]);
iw->save(TRasterImageP(rasImage));
}
} catch (...) {
string msg = "Frame " + frames[i].expand() + ": conversion failed!";
cout << msg << endl;
}
}
}
//-----------------------------------------------------------------------
void convertFromFullRaster(const TLevelReaderP &lr, const TLevelWriterP &lw, const vector<TFrameId> &frames,
const TAffine &aff, const TRop::ResampleFilterType &resType)
{
for (int i = 0; i < (int)frames.size(); i++) {
try {
TImageReaderP ir = lr->getFrameReader(frames[i]);
TRasterImageP img = ir->load();
TRaster32P raster(convert(aff * img->getBBox()).getSize());
if (!aff.isIdentity())
TRop::resample(raster, img->getRaster(), aff, resType);
else {
if ((TRaster32P)img->getRaster())
raster = img->getRaster();
else
TRop::convert(raster, img->getRaster());
}
TImageWriterP iw = lw->getFrameWriter(frames[i]);
iw->save(TRasterImageP(raster));
} catch (...) {
string msg = "Frame " + frames[i].expand() + ": conversion failed!";
cout << msg << endl;
}
}
}
//-----------------------------------------------------------------------
void convertFromFullRasterToCm(const TLevelReaderP &lr, const TLevelWriterP &lw, const vector<TFrameId> &frames,
const TAffine &aff, const TRop::ResampleFilterType &resType)
{
TPalette *plt = new TPalette();
for (int i = 0; i < (int)frames.size(); i++) {
try {
TImageReaderP ir = lr->getFrameReader(frames[i]);
TRasterImageP img = ir->load();
double dpix, dpiy;
img->getDpi(dpix, dpiy);
if (dpix == 0 && dpiy == 0)
dpix = dpiy = Preferences::instance()->getDefLevelDpi();
TRasterCM32P raster(convert(aff * img->getBBox()).getSize());
if (!aff.isIdentity()) {
TRaster32P raux(raster->getSize());
TRop::resample(raux, img->getRaster(), aff, resType);
TRop::convert(raster, raux);
} else
TRop::convert(raster, img->getRaster());
TImageWriterP iw = lw->getFrameWriter(frames[i]);
TToonzImageP outimg(raster, raster->getBounds());
outimg->setDpi(dpix, dpiy);
outimg->setPalette(plt);
iw->save(outimg);
} catch (...) {
string msg = "Frame " + frames[i].expand() + ": conversion failed!";
cout << msg << endl;
}
}
TFilePath pltPath = lw->getFilePath().withNoFrame().withType("tpl");
if (TSystem::touchParentDir(pltPath)) {
if (TSystem::doesExistFileOrLevel(pltPath))
TSystem::removeFileOrLevel(pltPath);
TOStream os(pltPath);
os << plt;
}
}
//-----------------------------------------------------------------------
void convert(const TFilePath &source, const TFilePath &dest, const RangeQualifier &range,
const IntQualifier &width, TPropertyGroup *prop,
const TRenderSettings::ResampleQuality &resQuality)
{
string msg;
//Carico le informazione del livello
TLevelReaderP lr(source);
TLevelP level = lr->loadInfo();
//Trovo i TFrameId corrispondenti al range
vector<TFrameId> frames = getFrameIds(range, level);
doesExist(dest);
msg = "Level loaded";
cout << msg << endl;
msg = "Conversion in progress: wait please...";
cout << msg << endl;
TAffine aff;
if (width.isSelected()) {
//calcolo un affine per fare la resample
int imgLx = lr->getImageInfo()->m_lx;
aff = TScale((double)width / (double)imgLx);
}
//setto il FilterResempleType giusto
TRop::ResampleFilterType resType;
if (resQuality == TRenderSettings::StandardResampleQuality)
resType = TRop::Triangle;
else if (resQuality == TRenderSettings::ImprovedResampleQuality)
resType = TRop::Hann2;
else if (resQuality == TRenderSettings::HighResampleQuality)
resType = TRop::Hamming3;
else if (resQuality == TRenderSettings::Triangle_FilterResampleQuality)
resType = TRop::Triangle;
else if (resQuality == TRenderSettings::Mitchell_FilterResampleQuality)
resType = TRop::Mitchell;
else if (resQuality == TRenderSettings::Cubic5_FilterResampleQuality)
resType = TRop::Cubic5;
else if (resQuality == TRenderSettings::Cubic75_FilterResampleQuality)
resType = TRop::Cubic75;
else if (resQuality == TRenderSettings::Cubic1_FilterResampleQuality)
resType = TRop::Cubic1;
else if (resQuality == TRenderSettings::Hann2_FilterResampleQuality)
resType = TRop::Hann2;
else if (resQuality == TRenderSettings::Hann3_FilterResampleQuality)
resType = TRop::Hann3;
else if (resQuality == TRenderSettings::Hamming2_FilterResampleQuality)
resType = TRop::Hamming2;
else if (resQuality == TRenderSettings::Hamming3_FilterResampleQuality)
resType = TRop::Hamming3;
else if (resQuality == TRenderSettings::Lanczos2_FilterResampleQuality)
resType = TRop::Lanczos2;
else if (resQuality == TRenderSettings::Lanczos3_FilterResampleQuality)
resType = TRop::Lanczos3;
else if (resQuality == TRenderSettings::Gauss_FilterResampleQuality)
resType = TRop::Gauss;
else if (resQuality == TRenderSettings::ClosestPixel_FilterResampleQuality)
resType = TRop::ClosestPixel;
else if (resQuality == TRenderSettings::Bilinear_FilterResampleQuality)
resType = TRop::Bilinear;
string ext = source.getType();
TLevelWriterP lw(dest, prop);
if (ext != "tlv" && ext != "pli") {
if (dest.getType() == "tlv")
convertFromFullRasterToCm(lr, lw, frames, aff, resType);
else
convertFromFullRaster(lr, lw, frames, aff, resType);
} else if (ext == "tlv") //ToonzImage
convertFromCM(lr, level->getPalette(), lw, frames, aff, resType);
else if (ext == "pli") //VectorImage
convertFromVI(lr, level->getPalette(), lw, frames, resType, width.getValue());
}
} //namespace
//------------------------------------------------------------------------
int main(int argc, char *argv[])
{
TEnv::setApplication(applicationName, applicationVersion);
TEnv::setRootVarName(rootVarName);
TEnv::setSystemVarPrefix(systemVarPrefix);
TFilePath fp = TEnv::getStuffDir();
string msg;
//Inizializzo i qualificatori
TCli::FilePathArgument srcName("srcName", "Source file");
TCli::FilePathArgument dstName("dstName", "Target file");
FilePathQualifier tnzName("-s sceneName", "Scene file");
RangeQualifier range;
IntQualifier width("-w width", "Image width");
Usage usage(argv[0]);
usage.add(srcName + dstName + width + tnzName + range);
if (!usage.parse(argc, argv))
exit(1);
try {
Tiio::defineStd();
//TPluginManager::instance()->loadStandardPlugins();
TSystem::hasMainLoop(false);
TPropertyGroup *prop = 0;
initImageIo();
TRenderSettings::ResampleQuality resQuality = TRenderSettings::StandardResampleQuality;
TFilePath dstFilePath = dstName.getValue();
TFilePath srcFilePath = srcName.getValue();
if (!TSystem::doesExistFileOrLevel(srcFilePath)) {
msg = srcFilePath.getLevelName() + " level doesn't exist.";
cout << endl
<< msg << endl;
exit(1);
}
msg = "Loading " + srcFilePath.getLevelName();
cout << endl
<< msg << endl;
string ext = dstFilePath.getType();
//controllo che ci sia un'estensione
if (ext == "") {
ext = ::to_string(dstFilePath);
if (ext == "") {
msg = "Invalid extension!";
cout << msg << endl;
exit(1);
}
}
if (dstFilePath.getParentDir().isEmpty()) //ho specificato solo l'estensione
dstFilePath = srcFilePath.getParentDir() + (srcFilePath.getName() + "." + ext);
if (tnzName.isSelected()) {
//Devo prendermi i settaggi degli "output setting" dalla scena!
TFilePath tnzFilePath = tnzName.getValue();
if (tnzFilePath.getType() != "tnz") {
msg = "Invalid scene file: conversion terminated!";
cout << msg << endl;
exit(1);
}
if (!TSystem::doesExistFileOrLevel(tnzFilePath))
return false;
ToonzScene *scene = new ToonzScene();
try {
scene->loadTnzFile(tnzFilePath);
} catch (...) {
string msg;
msg = "There were problems loading the scene " + ::to_string(srcFilePath) +
".\n Some files may be missing.";
cout << msg << endl;
//return false;
}
if (scene) {
resQuality = scene->getProperties()->getOutputProperties()->getRenderSettings().m_quality;
prop = scene->getProperties()->getOutputProperties()->getFileFormatProperties(ext);
} else {
msg = "Invalid scene file: conversion terminated!";
cout << msg << endl;
exit(1);
}
}
if (ext != "3gp" && ext != "pli") {
//assert(ext!="3gp" && ext!="pli" && ext!="tlv");
convert(srcFilePath, dstFilePath, range, width, prop, resQuality);
} else {
msg = "Cannot convert to ." + ext + " format.";
cout << msg << endl;
exit(1);
}
} catch (TException &e) {
msg = "Untrapped exception: " + ::to_string(e.getMessage());
cout << msg << endl;
return -1;
}
msg = "Conversion terminated!";
cout << endl
<< msg << endl;
return 0;
}
Reference in a new issue View git blame Copy permalink