KernelManagerContour.cxx

Go to the documentation of this file.

//----------------------------------------------------------------------------------------------------------------
// Class definition include
//----------------------------------------------------------------------------------------------------------------
#include "KernelManagerContour.h"


KernelManagerContour::KernelManagerContour(){


        inredo = 0;
        inundo = 0;

        time_t seconds;
        seconds = time (NULL);
        int time = seconds;


        stundoredo = "data/temp"+intToString(time);
        _currentIndex = 0;

        _contourPropagation = NULL;
#if(WIN32)
                mkdir(stundoredo.c_str());
#else
                mkdir(stundoredo.c_str(),755);
#endif
        stundoredo += "/cont";
}
KernelManagerContour::KernelManagerContour(std::vector<vtkImageData*> images,std::string datadir,std::string tmpdir)
{


        inredo = 0;
        inundo = 0;

        time_t seconds;
        seconds = time (NULL);
        int time = seconds;


        stundoredo = tmpdir+"/temp"+intToString(time);
        _currentIndex = 0;

        _contourPropagation = NULL;
#if(WIN32)
        mkdir(tmpdir.c_str());
        mkdir(stundoredo.c_str());
#else
        mkdir(tmpdir.c_str(),755);
        mkdir(stundoredo.c_str(),755);
#endif
        stundoredo += "/cont";
        setVectImages(images);        
        initializeEnvironment(datadir);

}

KernelManagerContour::~KernelManagerContour()
{
}

std::vector<vtkImageData*> KernelManagerContour::getVectImages()
{
        return vectimages;
}


void KernelManagerContour::setVectImages(std::vector<vtkImageData*> vectimg)
{
        double spc[3];
        std::vector<double> vectspc;
        
        for(int i = 0; i < (int)(vectimg.size()); i++){
                vtkImageData* img = vectimg[i];
                vtkImageChangeInformation* change = vtkImageChangeInformation::New();
                change->SetInformationInput(img);
                change->SetInputConnection(img->GetProducerPort());

                img->GetSpacing(spc);
                change->SetOutputSpacing(1,1,1);
                change->Update();

                vectspc.clear();
                vectspc.push_back(spc[0]);
                vectspc.push_back(spc[1]);
                vectspc.push_back(spc[2]);
                vectimagesSpacing.push_back(vectspc);
                vectimg[i] = change->GetOutput();
        }

        vectimages = vectimg;
}


void KernelManagerContour::GetSpacing(double *vecspc, int iImage)
{
        vecspc[0]=vectimagesSpacing[iImage][0];
        vecspc[1]=vectimagesSpacing[iImage][1];
        vecspc[2]=vectimagesSpacing[iImage][2];
}


void KernelManagerContour::initializeEnvironment(std::string datadir){
        _datadir = datadir;
        std::string conceptsFN                  =  datadir+"holaConceptsFile.cf";
        std::string imageSourcesFN              =  datadir+"holaImagesInstantsFile.of";
        std::string imageSectionsFN             = "";
        std::string axeThingsFN                 = "";

        std::map<std::string, ImageSourceThing *> * sourcesMap          = new std::map<std::string, ImageSourceThing *>();
        std::map<std::string, ImageSectionThing *>* sectionsMap         = new std::map<std::string, ImageSectionThing *>();
        std::map<std::string, AxeThing *>* axesMap                                      = new std::map<std::string, AxeThing *>();
        std::map<std::string, ContourThing *>* outlinesMap                      = new std::map<std::string, ContourThing *>();

        for(int i = 0; i < (int)(vectimages.size()); i++){
                vtkImageData* selectedimage = vectimages[i];
                ImageSourceThing * thing                                                                        = new ImageSourceThing(selectedimage);
                std::string imgstring = "Source Image "+intToString(i+1);
                sourcesMap->insert(std::pair<std::string, ImageSourceThing *>( imgstring, thing));
        }


        OutlineModelBuilder * _builder                                                          = new OutlineModelBuilder( conceptsFN ,datadir);
        _builder->buildImageSource_Envornment( imageSourcesFN, sourcesMap );
        _builder->buildImageSection_Envornment( imageSectionsFN, sectionsMap );
        _builder->buildAxe_Envornment(axeThingsFN, axesMap );
        _builder->buildCountour_Envornment( imageSectionsFN, outlinesMap );

        //Creating the objects to manage
        modelManager                            = new OutlineModelManager( _builder->getImSourceEnv(), _builder->getImSectionEnv(), _builder->getAxesEnv(),  _builder->getContourEnv() );

        imageSource     = modelManager->getImageSourceThingByKeyName( "Source Image 1" );

}
vtkImageData* KernelManagerContour::getSourceImage(){
        return imageSource->getSourceImage();
}
OutlineModelManager* KernelManagerContour::getOutlineModelManager(){
        return modelManager;
}

std::string KernelManagerContour::createOutline(manualBaseModel * manModelContour,std::vector<int> instantVector){
        return modelManager->createOutline( manModelContour, instantVector );
}

std::string KernelManagerContour::intToString(int num){
        std::string result;
        if(num == 0){
                result = "0";
        }else{
                int k=num;
                while (k > 0){
                        char temp = k % 10 + 48;
                        k = k / 10;
                        result = temp + result;
                }
        }
        return result;
}

std::vector<std::string> KernelManagerContour::GetLstNameThingsStatic(){
        return modelManager->GetLstNameThingsStatic();
}

void KernelManagerContour::SaveThingName(FILE* pFile, FILE *pFileData, std::string name ){
        modelManager->SaveThingName(pFile, pFileData, name);
}
std::vector<std::string> KernelManagerContour::GetLstNameThings(){
        return modelManager->GetLstNameThings();
}
//int KernelManagerContour::IsPartOfStaticList(std::string keyName ){
//      return modelManager->IsPartOfStaticList(keyName);
//}

bool KernelManagerContour::IsPartOfStaticList(std::string theKeyName){
        return modelManager->IsPartOfStaticList(theKeyName) == -1;
}

void KernelManagerContour::deleteCModel(std::string theKeyName){
        manualBaseModel* cModel         = modelManager->getOutlineByKeyName(theKeyName)->getModel();
        modelManager->removeOutline( theKeyName );

        delete cModel;
}

void KernelManagerContour::removeAllOutlines(){
        modelManager->removeAllOutlines();
}

std::vector<NameWrapper *> KernelManagerContour::getActualInstantOutlines(){
        return modelManager->getActualInstantOutlines();
}

int KernelManagerContour::getNamesWrappingSize(){
        return getActualInstantOutlines().size();
}

std::string KernelManagerContour::getNameWrapping(int i){
        return getActualInstantOutlines()[i]->getKeyName();
}

void KernelManagerContour::setInstant(Instant * theInstant){
        modelManager->setInstant(theInstant);
        //_actualInstant = theInstant;
}

Instant * KernelManagerContour::getCurrentInstant(){
        return modelManager->getInstant();
}
void KernelManagerContour::setInstant(std::vector<int> vectInstant){
        Instant* act = new Instant ( &vectInstant );
        modelManager->setInstant(act);
}

std::string KernelManagerContour::createCopyContourOf ( std::string anExistingKName, std::vector<int> &instantNoTouchData)
{
        return modelManager->createCopyContourOf(anExistingKName, instantNoTouchData);
}

manualBaseModel* KernelManagerContour::getOutlineByKeyName(std::string cloneName)
{
        return modelManager->getOutlineByKeyName (cloneName )->getModel();
}

bool KernelManagerContour::onRedo(std::string& filename){
        if(inredo > 0){
                inredo--;
                inundo++;
                std::string str = intToString(inundo);
                filename = stundoredo + str + ".roi";
                //loadState(temp);
                return true;
        }
        return false;
}

bool KernelManagerContour::onUndo(std::string& filename){
        if(inundo>0){
                inredo++;
                inundo--;

                //char str[9000];
                //itoa(inundo, str, 10);
                std::string str = intToString(inundo);


                filename = stundoredo + str + ".roi";

                return true;//loadState(temp);
        }
        return false;
}

std::string KernelManagerContour::saveState(){
        inredo=0;
        std::string str = intToString(inundo);
        std::string temp = stundoredo + str + ".roi";
        inundo++;
        return temp;
}

bool KernelManagerContour::onUndoSaveFile(std::string& filename){
        if(inundo>0){
                if(inredo==0){

                        //char str[9000];
                        //itoa(inundo, str, 10);
                        std::string str = intToString(inundo);

                        filename = stundoredo + str + ".roi";
                        return true;
                        //saveFileWithContours(temp);

                }
        }
        return false;
}

void KernelManagerContour :: changeContourOfManager(std::string keyName, Instant *instant)
{
        modelManager->ChangeContourOfList(keyName, instant);
}

void KernelManagerContour ::resetAppend()
{
    if (_contourPropagation!=NULL)
        {
                _contourPropagation->resetAppend();
        }
}


std::string KernelManagerContour::onSpreadAdd( std::vector<double> *vecX, std::vector<double> *vecY, std::vector<double> *vecZ, std::vector<int> instants)
{
    if (_contourPropagation==NULL)
    {
                _contourPropagation = new ContourPropagation();
    }

    if (vecX->size()!=0){

        int i,size=vecZ->size();
        int actualSlice = instants[1];
        for ( i=0 ; i<size ; i++ )
        {
            (*vecZ)[i] = actualSlice;
        } // for

        _contourPropagation->appendContour(vecX , vecY , vecZ);
        return intToString(actualSlice);
    }
        return "";
}


void KernelManagerContour::getMaxMinZ(double *minZ,double *maxZ)
{
    if (_contourPropagation!=NULL)
        {
                _contourPropagation->getMaxMinZ(minZ, maxZ);
        }
}


void KernelManagerContour::CalculeSplinePropagation()
{
        _contourPropagation->setInterpolationNumber(100);
        _contourPropagation->CalculeSplinePropagation();
}

manualBaseModel* KernelManagerContour::GetPoints(int z,int type, std::vector<double>* vecCtrlPointX,std::vector<double>* vecCtrlPointY,std::vector<double>* vecCtrlPointZ, std::string& theName,int typeofcontour, std::vector<int> tempVector)
{
        bool addedModel = false;
        manualBaseModel* manModelContour=NULL;

        if (_contourPropagation->ifSliceKeyContourExist(z)==false){

                manModelContour = factoryManualContourModel( typeofcontour );

                int idTmp = _contourPropagation->FindIdWithZ(z);

                if (type==0) // Initial Points
                {
                        _contourPropagation->GetInitialControlPoints( idTmp , vecCtrlPointX,vecCtrlPointY,vecCtrlPointZ);
                }
                if (type==1)  // Automatique Method
                {
                        _contourPropagation->GetControlPoints( idTmp  ,vecCtrlPointX,vecCtrlPointY,vecCtrlPointZ);
                }
                if (type==2)  // sampling
                {
                        _contourPropagation->GetControlPoints( idTmp , 20.0 ,vecCtrlPointX,vecCtrlPointY,vecCtrlPointZ);
                }
//--------------------------------------------------------------------
                int sizeCtrPt = vecCtrlPointX->size();
                for (int j=0 ; j<sizeCtrPt ; j++)
                {
//JSTG_16-07-08_----------------------------------------------------------------
                        manModelContour->AddPoint( (*vecCtrlPointX)[j] , (*vecCtrlPointY)[j] , -900  );
//--------------------------------------------------------------------
                } // for j

                tempVector[1]=z;
                theName = modelManager->createOutline( manModelContour, tempVector );
                addedModel = theName.compare("") != 0;
                if(!addedModel){
                        manModelContour = NULL;
                }

        }// ifSliceKeyContourExist
        return manModelContour;
}

manualBaseModel * KernelManagerContour::factoryManualContourModel(int typeContour)
{
        manualBaseModel *manModelContour=NULL;

        // Creating the model
        // NOTE: The view and the controler are created in the wxVtkBaseView_SceneManager class, configureViewControlTo method

        // spline
        if (typeContour==0)
        {
                manModelContour = new manualContourModel();
        }

        // spline
        if (typeContour==1)
        {
                manModelContour = new manualContourModel();
        }

        // rectangle
        if (typeContour==2)
        {
                manModelContour = new manualContourModelRoi();
        }

        // circle
        if (typeContour==3)
        {
                manModelContour = new manualContourModelCircle();
        }

        // line
        if (typeContour==6)
        {
                manModelContour = new manualContourModelLine();
        }

        // points
        if (typeContour==7)
        {
                manModelContour = new manualBaseModel();
        }

        // polygon
        if (typeContour==10)
        {
                manModelContour = new manualContourModelPolygon();
        }

        return manModelContour;
}

std::vector<std::string> KernelManagerContour::getOutlinesNameAtInstant(std::vector<int> tempvector){
        Instant instant(&tempvector);
        std::vector<ContourThing**> vectcont = modelManager->getOutlinesAtInstant( &instant );
        std::vector<std::string> vectname;
        for(int i = 0; i < (int)(vectcont.size()); i++){
                ContourThing **contourthing = vectcont[i];
                vectname.push_back((*contourthing)->getName());
        }
    return vectname;
}

std::vector<ContourThing**> KernelManagerContour::getOutlinesAtInstant(Instant* instant ){
        return modelManager->getOutlinesAtInstant(instant);
}

std::vector<manualBaseModel*> KernelManagerContour::ExploseEachModel( std::vector<manualBaseModel*> lstManConMod ){
        std::vector<manualBaseModel*> lstTmp;
        std::vector<manualBaseModel*> lstResult;
        int j,jSize;
        int i,iSize=lstManConMod.size();
        for (i=0;i<iSize;i++)
        {
                lstTmp = lstManConMod[i]->ExploseModel();
                jSize=lstTmp.size();
                for (j=0;j<jSize;j++)
                {
                        lstResult.push_back( lstTmp[j] );
                }
        }
        return lstResult;
}

void KernelManagerContour::getConceptsInformation(std::vector<std::string>& conceptNameVect, std::vector<int>& conceptSizeVect){
        modelManager-> getConceptsInformation(conceptNameVect, conceptSizeVect);
}


vtkImageData* KernelManagerContour::getImageAtInstant(std::vector<int> inst){
        int index = inst[5]-1;

        if(index < (int)(vectimages.size())&&index!=_currentIndex){
                _currentIndex=index;
                return vectimages[index];
        }
        return NULL;
}

std::string KernelManagerContour::getCurrentFileName(){
        return filename;
}

void KernelManagerContour::setCurrentFileName(std::string filenam){
        this->filename = filenam;
}

std::string KernelManagerContour::parseOsirixFile(std::string filename){


#ifdef ParserOsirix_BUILD
        vtkImageData* sourceimage;
        std::string xsdfile;

        xsdfile = _datadir;

        xsdfile.append("\\XML\\osirixschema.xsd");

        sourceimage = getSourceImage();
        OsirixParser p(xsdfile.c_str(), sourceimage->GetSpacing(), sourceimage->GetExtent());

        if(p.ParseFile(filename.c_str())!= 0){

        }

        return p.getContoursFileName();
#else
        return "";
#endif


}