main.cpp

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#include "convertToString.h"
#include "PPath.h"
#include "OptionParser.h"
#include "pxml_utils.h"
 
#include "pinkscape_slide.h"


OptionParser createOptionParser(){
        OptionParser parser(true, __PROGRAM_VERSION__);
        parser.setExampleLongOption("phoenix_inkscapesplitter --input=file.svg --output=output/dir/");
        parser.setExampleShortOption("phoenix_inkscapesplitter -i file1.svg file1.svg fileN.svg -o output/dir/");
        
        parser.addOption("input", "i", OptionType::FILENAME, true, "list of input files to be treated");
        
        PString defaultOutputDir(".");
        parser.addOption("output", "o", defaultOutputDir, "Output directory");
        
        return parser;
}

struct PLayer{
        long unsigned int begin;
        long unsigned int end;
        PString command;
};

typedef std::vector<PLayer> PVecLayer;

typedef std::vector<long unsigned int> PSlide;

typedef std::vector<PSlide > PVecSlide;


PString getInkscapeLabel(const PXml & layerXml){
        PString attr("");
        PXmlAttr attrXml;
        if(pxml_getAttrIfExist(attrXml, layerXml, "inkscape:label")){
                attr = attrXml.getValue();
        }
        return attr;
}


void createVectorSlide(PVecLayer & vecLayerSlide, const PVecXml & vecLayer){
        long unsigned int i(0lu);
        for(PVecXml::const_iterator itLayer(vecLayer.begin()); itLayer != vecLayer.end(); ++itLayer){
                PString inkscapeLabel(getInkscapeLabel(*itLayer));
                std::cout << "\tlayer '" << inkscapeLabel  << "'";
                PVecString listNb(inkscapeLabel.split('-'));
                long unsigned int begin(0lu), end(0lu);
                bool isBeginDefined(false), isEndDefine(false);
                PString command("");
                for(PVecString::iterator it(listNb.begin()); it != listNb.end(); ++it){
                        if(it->isNumber()){
                                if(isBeginDefined){
                                        end = atol(it->c_str());
                                        isEndDefine = true;
                                }else{
                                        begin = atol(it->c_str());
                                        isBeginDefined = true;
                                }
                        }else{
                                if(*it == "N" && isBeginDefined){
                                        command = "UntilEnd";
                                        std::cout << "\t=> until end";
                                }
                                
                        }
                }
                std::cout << std::endl;
                if(!isBeginDefined && !isEndDefine){
                        begin = i;
                        end = i;
                }
                PLayer layer;
                layer.command = command;
                layer.begin = begin;
                if(isEndDefine){layer.end = end;}
                else{layer.end = begin;}
                vecLayerSlide.push_back(layer);
        }
}


void createSlideWithLayer(PSlide & slide, const PVecLayer & vecLayerSlide, long unsigned int index){
        long unsigned int i(0lu);
        for(PVecLayer::const_iterator it(vecLayerSlide.begin()); it != vecLayerSlide.end(); ++it){
                if(index >= it->begin && index <= it->end){
                        slide.push_back(i);
                }
                ++i;
        }
}


void createVecSlide(PVecSlide & vecSlide, PVecLayer & vecLayerSlide){
        if(vecLayerSlide.size() == 0lu){return;}
        PVecLayer::iterator it(vecLayerSlide.begin());
        long unsigned int minSlide(it->begin), maxSlide(it->end);
        ++it;
        while(it != vecLayerSlide.end()){
                if(it->begin < minSlide){minSlide = it->begin;}
                if(it->end > maxSlide){maxSlide = it->end;}
                ++it;
        }
        for(PVecLayer::iterator itCmd(vecLayerSlide.begin()); itCmd != vecLayerSlide.end(); ++itCmd){
                if(itCmd->command == "UntilEnd"){
                        itCmd->end = maxSlide;
                }
        }
        for(long unsigned int i(minSlide); i < maxSlide + 1lu; ++i){
                PSlide slide;
                createSlideWithLayer(slide, vecLayerSlide, i);
                vecSlide.push_back(slide);
        }
}


PString getSlideNumber(long unsigned int i){
        if(i < 10lu){
                return "0" + valueToString(i);
        }else{
                return valueToString(i);
        }
}


bool saveSlides(POutoutMode & outputMode, const PPath & baseOutputName,
                const PVecSlide & vecSlides, const PVecXml & vecLayerXml, const PXml & lighRoot)
{
        long unsigned int i(0lu);
        for(PVecSlide::const_iterator itSlide(vecSlides.begin()); itSlide != vecSlides.end(); ++itSlide){
                PXml tmpRoot(lighRoot);
                tmpRoot.setName("");
                PXml * svgPtr = pxml_getChildPtr(tmpRoot, "svg");
                const PSlide & slide = *itSlide;
                for(PSlide::const_iterator it(slide.begin()); it != slide.end(); ++it){
//                      We need to suppress attribute : style="display:none"
                        PXml tmpLayer(vecLayerXml[*it]);
                        pxml_setAttr(tmpLayer, "style", "display:inline");
                        svgPtr->getVecChild().push_back(tmpLayer);      //We add the corresponding layer
                }
                //Save svg file
                PPath outputSlide(PPath("./") + baseOutputName + PPath("_") + getSlideNumber(i) + PPath(".svg"));
                //Get the svg content
                PString slideContent(pxml_baliseStr(tmpRoot, true));
                //Check if the svg is already saved
                if(pinkscape_isSlideKnown(outputMode, outputSlide, slideContent)){
                        continue;
                }
                //If not, save the svg into png image
                if(!outputSlide.saveFileContent(slideContent)){
                        std::cerr << "saveSlides : can't save svg file '"<<outputSlide<<"'" << std::endl;
                        return false;
                }
                //Call inkscape to make png file
                PPath outputSlidePng(baseOutputName + PPath("_") + getSlideNumber(i) + PPath(".png"));
//              PString command("inkscape --without-gui -e "+outputSlidePng+" "+outputSlide);
                PString command(PString("convert ") + outputSlide + PString(" ") + outputSlidePng);
//              PString command("inkscape --batch-process -o "+outputSlidePng+" "+outputSlide); //for Inkscape 1.1.2 (0a00cf5339, 2022-02-04)
                
                if(system(command.c_str()) != 0){
                        std::cerr << "saveSlides : can't create png file with command '"<<command<<"'" << std::endl;
                        return false;
                }
                //Removing the temporary svg files
                command = PString("rm ") + outputSlide;
                if(system(command.c_str()) != 0){
                        std::cerr << "saveSlides : can't remove temporary svg file with command '"<<command<<"'" << std::endl;
                        return false;
                }
                ++i;
        }
        return true;
}


bool processFileSvg(const PPath & inputFile){
        if(inputFile == ""){return false;}
        PXml root;
        if(!pxml_parserFile(root, inputFile)){
                std::cerr << "processFileSvg : can't load file '"<<inputFile<<"'" << std::endl;
                return false;
        }
//      cout << "processFileSvg : root nbChild : " << root.getVecChild().size() << endl;
//      PVecXml & vecChild = root.getVecChild();
//      for(PVecXml::iterator it(vecChild.begin()); it != vecChild.end(); ++it){
//              cout << "processFileSvg : '" << it->getName() << "'" << endl;
//      }
        PXml svgBalise;
        if(!pxml_getChildIfExist(svgBalise, root, "svg")){
                std::cerr << "processFileSvg : can't find 'svg' balise in root" << std::endl;
                return false;
        }
        
//      PVecXml & vecChildSvg = svgBalise.getVecChild();
//      for(PVecXml::iterator it(vecChildSvg.begin()); it != vecChildSvg.end(); ++it){
//              cout << "processFileSvg : svg '" << it->getName() << "'" << endl;
//      }
        
        PVecXml vecLayer;
        if(!pxml_getVecChildIfExist(vecLayer, svgBalise, "g")){
                std::cerr << "processFileSvg : can't find 'g' balise in svg" << std::endl;
                return false;
        }
        long unsigned int nbCalque(vecLayer.size());
        std::cout << "processFileSvg : get " << nbCalque << " layer";
        if(nbCalque > 1lu){std::cout << "s";}
        std::cout << std::endl;
        
        PVecLayer vecLayerSlide;
        createVectorSlide(vecLayerSlide, vecLayer);
        if(vecLayerSlide.size() == 0lu){
                std::cerr << "processFileSvg : no layer defined with -begin-end synthax" << std::endl;
                return false;
        }
        PVecSlide vecSlides;
        createVecSlide(vecSlides, vecLayerSlide);
        
        PXml lighRoot(root);
        PXml * svgPtr = pxml_getChildPtr(lighRoot, "svg");
        PXml svgNoLayer(pxml_eraseVecChild(*svgPtr, "g"));
        *svgPtr = svgNoLayer;
        
        POutoutMode outputMode;
        PString baseOutputSlideName(inputFile.getFileName().eraseExtension());
        pinkscape_loadSlideMap(outputMode.mapSlide, baseOutputSlideName);
        bool b = saveSlides(outputMode, baseOutputSlideName, vecSlides, vecLayer, lighRoot);
        pinkscape_saveSlideMap(outputMode.mapSlide, baseOutputSlideName);
        return b;
}


int processFiles(const std::vector<PPath> & listInputFile){
        if(listInputFile.size() == 0lu){
                std::cerr << "processFiles : no input file" << std::endl;
                return -1;
        }
        bool b(true);
        for(std::vector<PPath>::const_iterator it(listInputFile.begin()); it != listInputFile.end() && b; ++it){
                b &= processFileSvg(*it);
        }
        return 1 - b;
}
 
int main(int argc, char** argv){
        OptionParser parser = createOptionParser();
        parser.parseArgument(argc, argv);
        
        const OptionMode & defaultMode = parser.getDefaultMode();
        std::vector<PPath> listInputFile;
        defaultMode.getValue(listInputFile, "input");
        
        return processFiles(listInputFile);
}