+/*# ---------------------------------------------------------------------
+#
+# Copyright (c) CREATIS (Centre de Recherche en Acquisition et Traitement de l'Image
+# pour la Sant�)
+# Authors : Eduardo Davila, Frederic Cervenansky, Claire Mouton
+# Previous Authors : Laurent Guigues, Jean-Pierre Roux
+# CreaTools website : www.creatis.insa-lyon.fr/site/fr/creatools_accueil
+#
+# This software is governed by the CeCILL-B license under French law and
+# abiding by the rules of distribution of free software. You can use,
+# modify and/ or redistribute the software under the terms of the CeCILL-B
+# license as circulated by CEA, CNRS and INRIA at the following URL
+# http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
+# or in the file LICENSE.txt.
+#
+# As a counterpart to the access to the source code and rights to copy,
+# modify and redistribute granted by the license, users are provided only
+# with a limited warranty and the software's author, the holder of the
+# economic rights, and the successive licensors have only limited
+# liability.
+#
+# The fact that you are presently reading this means that you have had
+# knowledge of the CeCILL-B license and that you accept its terms.
+# ------------------------------------------------------------------------ */
+
//----------------------------------------------------------------------------------------------------------------
// Class definition include
**
**/
inredo = 0;
- inundo = 0;
+ inundo = 0;
time_t seconds;
seconds = time (NULL);
**/
}
-KernelManagerContour::KernelManagerContour(std::vector<vtkImageData*> images,std::string datadir,std::string tmpdir){
+KernelManagerContour::KernelManagerContour(std::vector<vtkImageData*> images,std::string datadir,std::string tmpdir)
+{
/**THIS ALL SHOULD BE IN AN OTHER LIB CALLED PERSISTANCE
**
**/
inredo = 0;
- inundo = 0;
+ inundo = 0;
time_t seconds;
seconds = time (NULL);
stundoredo = tmpdir+"/temp"+intToString(time);
_currentIndex = 0;
-
+
_contourPropagation = NULL;
#if(WIN32)
mkdir(tmpdir.c_str());
/**
** FINISH PERSISTANCE
**/
- setVectImages(images);
+ setVectImages(images);
initializeEnvironment(datadir);
}
-KernelManagerContour::~KernelManagerContour(){
-}
-std::vector<vtkImageData*> KernelManagerContour::getVectImages(){
+KernelManagerContour::~KernelManagerContour()
+{
+}
+
+std::vector<vtkImageData*> KernelManagerContour::getVectImages()
+{
return vectimages;
}
-void KernelManagerContour::setVectImages(std::vector<vtkImageData*> vectimg){
- for(int i = 0; i < vectimg.size(); i++){
+
+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::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 *>();
+ std::map<std::string, ContourThing *>* outlinesMap = new std::map<std::string, ContourThing *>();
- for(int i = 0; i < vectimages.size(); i++){
+ 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->buildImageSection_Envornment( imageSectionsFN, sectionsMap );
_builder->buildAxe_Envornment(axeThingsFN, axesMap );
_builder->buildCountour_Envornment( imageSectionsFN, outlinesMap );
return modelManager;
}
-std::string KernelManagerContour::createOutline(manualContourModel * manModelContour,std::vector<int> instantVector){
+std::string KernelManagerContour::createOutline(manualBaseModel * manModelContour,std::vector<int> instantVector){
return modelManager->createOutline( manModelContour, instantVector );
}
while (k > 0){
char temp = k % 10 + 48;
k = k / 10;
- result = temp + result;
+ result = temp + result;
}
}
return result;
return modelManager->GetLstNameThingsStatic();
}
-void KernelManagerContour::SaveThingName(FILE* pFile, std::string name ){
- modelManager->SaveThingName(pFile, name);
+void KernelManagerContour::SaveThingName(FILE* pFile, FILE *pFileData, std::string name ){
+ modelManager->SaveThingName(pFile, pFileData, name);
}
std::vector<std::string> KernelManagerContour::GetLstNameThings(){
return modelManager->GetLstNameThings();
}
void KernelManagerContour::deleteCModel(std::string theKeyName){
- manualContourModel* cModel = modelManager->getOutlineByKeyName(theKeyName)->getModel();
+ manualBaseModel* cModel = modelManager->getOutlineByKeyName(theKeyName)->getModel();
modelManager->removeOutline( theKeyName );
delete cModel;
{
return modelManager->createCopyContourOf(anExistingKName, instantNoTouchData);
}
-manualContourModel* KernelManagerContour::getOutlineByKeyName(std::string cloneName){
+
+manualBaseModel* KernelManagerContour::getOutlineByKeyName(std::string cloneName)
+{
return modelManager->getOutlineByKeyName (cloneName )->getModel();
}
if(inredo > 0){
inredo--;
inundo++;
- std::string str = intToString(inundo);
- filename = stundoredo + str + ".roi";
- //loadState(temp);
+ std::string str = intToString(inundo);
+ filename = stundoredo + str + ".roi";
+ //loadState(temp);
return true;
}
return false;
}
bool KernelManagerContour::onUndo(std::string& filename){
- if(inundo>0){
+ if(inundo>0){
inredo++;
inundo--;
//itoa(inundo, str, 10);
std::string str = intToString(inundo);
-
+
filename = stundoredo + str + ".roi";
-
+
return true;//loadState(temp);
}
return false;
filename = stundoredo + str + ".roi";
return true;
- //saveFileWithContours(temp);
+ //saveFileWithContours(temp);
}
}
modelManager->ChangeContourOfList(keyName, instant);
}
-void KernelManagerContour ::resetAppend(){
- if(isInitContourPropagation()){
+void KernelManagerContour ::resetAppend()
+{
+ if (_contourPropagation!=NULL)
+ {
_contourPropagation->resetAppend();
- }
-}
-
-bool KernelManagerContour::isInitContourPropagation(){
- if(_contourPropagation == NULL){
- _contourPropagation = new ContourPropagation();
- }else{
- return true;
}
- return false;
-
}
-std::string KernelManagerContour::onSpreadAdd( std::vector<double> *vecX, std::vector<double> *vecY, std::vector<double> *vecZ, std::vector<int> instants){
- if(isInitContourPropagation()){
- 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);
- }
- }
+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(isInitContourPropagation()){
+
+void KernelManagerContour::getMaxMinZ(double *minZ,double *maxZ)
+{
+ if (_contourPropagation!=NULL)
+ {
_contourPropagation->getMaxMinZ(minZ, maxZ);
}
}
-void KernelManagerContour::CalculeSplinePropagation(){
+
+
+void KernelManagerContour::CalculeSplinePropagation()
+{
_contourPropagation->setInterpolationNumber(100);
_contourPropagation->CalculeSplinePropagation();
}
-manualContourModel* 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){
-
-
+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;
- manualContourModel* manModelContour=NULL;
+ manualBaseModel* manModelContour=NULL;
if (_contourPropagation->ifSliceKeyContourExist(z)==false){
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(!addedModel){
manModelContour = NULL;
}
-
+
}// ifSliceKeyContourExist
return manModelContour;
-
}
-manualContourModel * KernelManagerContour::factoryManualContourModel(int typeContour)
-{
- manualContourModel *manModelContour=NULL;
+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 manualContourModelLine();
}
+ // points
+ if (typeContour==7)
+ {
+ manModelContour = new manualBaseModel();
+ }
+
+ // polygon
+ if (typeContour==10)
+ {
+ manModelContour = new manualContourModelPolygon();
+ }
+
return manModelContour;
}
Instant instant(&tempvector);
std::vector<ContourThing**> vectcont = modelManager->getOutlinesAtInstant( &instant );
std::vector<std::string> vectname;
- for(int i = 0; i < vectcont.size(); i++){
+ for(int i = 0; i < (int)(vectcont.size()); i++){
ContourThing **contourthing = vectcont[i];
vectname.push_back((*contourthing)->getName());
}
- return vectname;
+ return vectname;
}
std::vector<ContourThing**> KernelManagerContour::getOutlinesAtInstant(Instant* instant ){
return modelManager->getOutlinesAtInstant(instant);
}
-std::vector<manualContourModel*> KernelManagerContour::ExploseEachModel( std::vector<manualContourModel*> lstManConMod ){
- std::vector<manualContourModel*> lstTmp;
- std::vector<manualContourModel*> lstResult;
+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++)
vtkImageData* KernelManagerContour::getImageAtInstant(std::vector<int> inst){
int index = inst[5]-1;
- if(index < vectimages.size()&&index!=_currentIndex){
+ if(index < (int)(vectimages.size())&&index!=_currentIndex){
_currentIndex=index;
return vectimages[index];
}
void KernelManagerContour::setCurrentFileName(std::string filenam){
this->filename = filenam;
-}
\ No newline at end of file
+}
+
+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
+
+
+}
+
+
git://git.creatis.insa-lyon.fr / creaContours.git / blobdiff