OutlineModelManager Class Reference

#include <OutlineModelManager.h>

Collaboration diagram for OutlineModelManager:

Public Member Functions
	OutlineModelManager (SomeEnvironment< ImageSourceThing * > *imSourceEnv, SomeEnvironment< ImageSectionThing * > *imSectionEnv, SomeEnvironment< AxeThing * > *axesEnv, SomeEnvironment< ContourThing * > *contourEnv)
	~OutlineModelManager ()
ContourWorkspace *	createWorkSpace ()
void	setWorkSpace (ContourWorkspace *aWorkSpace)
bool	executeCommand_OutlineModel (std::string outKName, CommandObject *theCommand, bool fromRegistration)
bool	executeCommand (CommandObject *theCommand, bool fromRegistration=false)
bool	executeCommandsQueue (std::deque< CommandObject * > executionQueue, bool fromRegistration=false)
bool	setUserConcepts (std::string conceptsScript)
bool	addUserConcept (std::string theConceptName, int conceptSize)
std::vector< NameWrapper * >	getActualInstantOutlines ()
std::vector< ContourThing ** >	getOutlinesAtInstant (Instant *anInstant, bool ifAnnotate=true)
std::vector< std::string >	GetLstNameThings ()
std::vector< std::string >	GetLstNameThingsStatic ()
std::vector< ContourThing * >	getOutlinesFromGroup (std::string aGroupName)
bool	addOutlinesGroup (std::string theOutlineName, OutlineGroup *theGroup)
ContourThing *	getOutlineByKeyName (std::string outKName)
ImageSourceThing *	getImageSourceThingByKeyName (std::string iSeourceKName)
ImageSectionThing *	getImageSectionThingByKeyName (std::string iSectionName)
std::string	createOutline (manualBaseModel *model, std::vector< int > theInstantData, std::string aName="")
bool	createAxe (std::string aDescription, Instant *theInstantData)
bool	createImageSource (std::string aSource, Instant *theInstantData)
bool	createImageSection (std::string aSecImageData, Instant *theInstantData)
std::string	addOutline (ContourThing *theOutline, Instant *theInstantData)
void	removeOutline (std::string ss)
bool	addAxe (AxeThing *thaAxe, Instant *theInstantData)
bool	addImageSource (ImageSourceThing *imageSource, Instant *theInstantData)
bool	addImageSection (ImageSectionThing *imageSection, Instant *theInstantData)
void	annotateOutlineWrap (std::string kOutlineName, std::string theRealName)
void	annotateOutlinesWrap (std::vector< std::string > keyNames, std::vector< ContourThing ** > theOutlinesVector)
void	annotateActualOutlineWrap (std::string actualKeyOutline, std::string theRealName)
void	annotateActualAxeWrap (std::string actualKeyAxe, std::string theRealName)
void	annotateActualSectionImageWrap (std::string actualKeyImage, std::string theRealName)
void	annotateActualSourceImageWrap (std::string actualKeyImage, std::string theRealName)
void	setInstant (Instant *newActualInstantData)
AxeThing *	getAxeByKeyName (std::string axeKName)
std::vector< Instant * >	getOutlineInstantsByName (std::string thekName)
std::vector< Instant * >	getOutlineInstants ()
bool	includeOutlineInstant (std::string outKName, Instant *anInstantData)
bool	includeAxeInstant (std::string axeKName, Instant *anInstantData)
bool	includeImageSectionInstant (std::string imaKName, Instant *anInstantData)
bool	includeImageSourceInstant (std::string imaKName, Instant *anInstantData)
void	getConceptsInformation (std::vector< std::string > &conceptNameVect, std::vector< int > &conceptSizeVect)
ContourWorkspace *	getContourWorkspace ()
int	getGroupsCount ()
void	clean ()
void	removeAllOutlines ()
std::string	createCopyContourOf (std::string anExistingKName, std::vector< int > &instantNoTouchData)
void	SaveThingName (FILE *pFile, FILE *pFileData, std::string nameThing)
void	ChangeContourOfList (std::string keyName, Instant *instant)
int	IsPartOfStaticList (std::string ss)
Instant *	getInstant ()

Private Member Functions
void	updateToActualInstant ()
bool	setAutomaticConcepts ()

Private Attributes
std::string	actualGruopID
SomeEnvironment< AxeThing * > *	axesEnvironment
SomeEnvironment < ImageSectionThing * > *	imagesSectionEnvironment
SomeEnvironment < ImageSourceThing * > *	imageSourceEnvironment
SomeEnvironment< ContourThing * > *	outlinesEnvironment
std::map< std::string, OutlineGroup * >	outlineGroups
ContourWorkspace *	workSpace
InstantMembersNameList *	actualInstantWrapping
bool	changeSourceImage
int	counterIdKey
PrefixMaxKeyGenerator	keyGenerator
std::string	axeConcept
std::string	axeDepthConcept
Instant *	actualInstant
std::vector< ContourThing ** >	staticContourLst

Detailed Description

Definition at line 60 of file OutlineModelManager.h.

Constructor & Destructor Documentation

OutlineModelManager::OutlineModelManager	(	SomeEnvironment< ImageSourceThing * > *	imSourceEnv,
		SomeEnvironment< ImageSectionThing * > *	imSectionEnv,
		SomeEnvironment< AxeThing * > *	axesEnv,
		SomeEnvironment< ContourThing * > *	contourEnv
	)

Definition at line 43 of file OutlineModelManager.cxx.

References actualInstant, actualInstantWrapping, PrefixMaxKeyGenerator::addKeyThing(), axesEnvironment, changeSourceImage, counterIdKey, imageSourceEnvironment, imagesSectionEnvironment, keyGenerator, outlinesEnvironment, and workSpace.

        {
                actualInstant                           = NULL;
                imageSourceEnvironment          = imSourceEnv;
                imagesSectionEnvironment        = imSectionEnv;
                axesEnvironment                         = axesEnv;
                outlinesEnvironment                     = contourEnv;

                workSpace                                       = new ContourWorkspace(this);//implies a shared workSpace
                keyGenerator                            = * new PrefixMaxKeyGenerator();
                counterIdKey                            = 0;

                actualInstantWrapping           = new InstantMembersNameList();
                changeSourceImage                       = true;

                bool allOK      = keyGenerator.addKeyThing("Axes", "Axe");
                allOK &= keyGenerator.addKeyThing("Image Sources", "Image source");
                allOK &= keyGenerator.addKeyThing("Image Sections", "Image section");
                allOK &= keyGenerator.addKeyThing("Outlines", "Outline");
                //setAutomaticConcepts();
        }

Here is the call graph for this function:

OutlineModelManager::~OutlineModelManager

(

)

Definition at line 68 of file OutlineModelManager.cxx.

References actualInstant, actualInstantWrapping, clean(), and workSpace.

        {
                clean();
                delete actualInstant;
                delete workSpace;
                delete actualInstantWrapping;
        }

Here is the call graph for this function:

Member Function Documentation

bool OutlineModelManager::addAxe	(	AxeThing *	thaAxe,
		Instant *	theInstantData
	)

Definition at line 489 of file OutlineModelManager.cxx.

References axesEnvironment, PrefixMaxKeyGenerator::generateKeyOf(), and keyGenerator.

Referenced by createAxe().

        {
                std::string kName;
                bool added  = keyGenerator.generateKeyOf("Axes", axesEnvironment->getNumberOfThings(),kName);
                added &= axesEnvironment->addThingWithInstant(kName,theAxe, theInstantData);
                return added;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

bool OutlineModelManager::addImageSection	(	ImageSectionThing *	imageSection,
		Instant *	theInstantData
	)

Definition at line 517 of file OutlineModelManager.cxx.

References PrefixMaxKeyGenerator::generateKeyOf(), imagesSectionEnvironment, and keyGenerator.

        {
                std::string kName;
                bool added  = keyGenerator.generateKeyOf("Image Sections", imagesSectionEnvironment->getNumberOfThings(),kName);
                added &= imagesSectionEnvironment->addThingWithInstant(kName, imageSection, theInstantData);
                return added;
        }

Here is the call graph for this function:

bool OutlineModelManager::addImageSource	(	ImageSourceThing *	imageSource,
		Instant *	theInstantData
	)

Definition at line 503 of file OutlineModelManager.cxx.

References PrefixMaxKeyGenerator::generateKeyOf(), imageSourceEnvironment, and keyGenerator.

        {
                std::string kName;
                bool added  = keyGenerator.generateKeyOf("Image Sources", imageSourceEnvironment->getNumberOfThings(),kName);
                added &= imageSourceEnvironment->addThingWithInstant(kName,imageSource, theInstantData );
                return added;
        }

Here is the call graph for this function:

std::string OutlineModelManager::addOutline	(	ContourThing *	theOutline,
		Instant *	theInstantData
	)

Definition at line 418 of file OutlineModelManager.cxx.

References counterIdKey, PrefixMaxKeyGenerator::generateKeyOf(), ContourThing::getName(), keyGenerator, outlinesEnvironment, and ContourThing::setName().

Referenced by createOutline().

        {
                std::string kName;

// EED
//              bool added  = keyGenerator.generateKeyOf("Outlines", outlinesEnvironment->getNumberOfThings(),kName);

                counterIdKey++;
                bool added = keyGenerator.generateKeyOf( "Outlines", counterIdKey , kName );

                if( theOutline->getName().compare("")==0 )
                {
                        theOutline->setName(kName);
                }
                added &= outlinesEnvironment->addThingWithInstant(kName,theOutline, theInstantData);
                if( added )
                        return kName;
                else
                        return "";
        }

Here is the call graph for this function:

Here is the caller graph for this function:

bool OutlineModelManager::addOutlinesGroup	(	std::string	theOutlineName,
		OutlineGroup *	theGroup
	)

Adds to storing at (outlineGroups) an outline group given its name and the group

Parameters

theOutlineName	The name of the group containing the outlines names to add
theGroup	The outlines group to add

Returns

Returns true

Gets the outlines at a specific form the outline's environment

Parameters

aGroupName

The name of the group containing the outlines names to get

Returns

The vector to the outlineGroups at the given group

Definition at line 321 of file OutlineModelManager.cxx.

References outlineGroups.

        {
        outlineGroups.insert(std::pair <std::string, OutlineGroup *> ( theOutlineName, theGroup ));
//              std::map<std::string, OutlineGroup *> :: iterator iter = NULL;
                std::map<std::string, OutlineGroup *> :: iterator iter;
                iter = outlineGroups.find( theOutlineName );
                bool ifAdded = iter->first.compare( theOutlineName ) == 0;
                return ifAdded;
        }

bool OutlineModelManager::addUserConcept	(	std::string	theConceptName,
		int	conceptSize
	)

Definition at line 202 of file OutlineModelManager.cxx.

References axesEnvironment, imageSourceEnvironment, imagesSectionEnvironment, and outlinesEnvironment.

Referenced by setUserConcepts().

        {
                bool allOK = axesEnvironment->addConcept(theConceptName, conceptSize);
                allOK &= imagesSectionEnvironment->addConcept(theConceptName, conceptSize);
                allOK &= imageSourceEnvironment->addConcept(theConceptName, conceptSize);
                allOK &= outlinesEnvironment->addConcept(theConceptName, conceptSize);
                return allOK;
        }

Here is the caller graph for this function:

void OutlineModelManager::annotateActualAxeWrap	(	std::string	actualKeyAxe,
		std::string	theRealName
	)

Definition at line 565 of file OutlineModelManager.cxx.

References actualInstantWrapping.

        {
                actualInstantWrapping -> setActualAxeWrap(actualKeyAxe, theRealName);
        }

void OutlineModelManager::annotateActualOutlineWrap	(	std::string	actualKeyOutline,
		std::string	theRealName
	)

Definition at line 555 of file OutlineModelManager.cxx.

References actualInstantWrapping.

        {
                actualInstantWrapping -> setActualOutline(actualKeyOutline, theRealName);
        }

void OutlineModelManager::annotateActualSectionImageWrap	(	std::string	actualKeyImage,
		std::string	theRealName
	)

Definition at line 575 of file OutlineModelManager.cxx.

References actualInstantWrapping.

        {
                actualInstantWrapping -> setActualSectionImageNamesWrapp(actualKeyImage, theRealName);
        }

void OutlineModelManager::annotateActualSourceImageWrap	(	std::string	actualKeyImage,
		std::string	theRealName
	)

Definition at line 585 of file OutlineModelManager.cxx.

References actualInstantWrapping.

        {
                actualInstantWrapping -> setActualSourceImageNamesWrapp(actualKeyImage, theRealName);
        }

void OutlineModelManager::annotateOutlinesWrap	(	std::vector< std::string >	keyNames,
		std::vector< ContourThing ** >	theOutlinesVector
	)

Definition at line 540 of file OutlineModelManager.cxx.

References actualInstantWrapping, InstantMembersNameList::clean(), and ContourThing::getName().

Referenced by getOutlinesAtInstant().

        {
                actualInstantWrapping ->clean();
                for(int i=0; i<kNamesVector.size(); i++)
                {
                        ContourThing * anOutline = *theOutlinesVector[i];
                        actualInstantWrapping -> addOutlineName( kNamesVector[i], anOutline->getName() );
                }
        }

Here is the call graph for this function:

Here is the caller graph for this function:

void OutlineModelManager::annotateOutlineWrap	(	std::string	kOutlineName,
		std::string	theRealName
	)

Definition at line 530 of file OutlineModelManager.cxx.

References actualInstantWrapping.

        {
                actualInstantWrapping -> addOutlineName(kOutlineName, theRealName);
        }

void OutlineModelManager::ChangeContourOfList	(	std::string	keyName,
		Instant *	instant
	)

Definition at line 223 of file OutlineModelManager.cxx.

References IsPartOfStaticList(), outlinesEnvironment, and staticContourLst.

Referenced by KernelManagerContour::changeContourOfManager().

        {
                int ispartofstaticlist = IsPartOfStaticList(keyName);
                if (ispartofstaticlist==-1)
                {
                        staticContourLst.push_back(  this->outlinesEnvironment->getThingByName(keyName)  );
                        this->outlinesEnvironment->removeThingFromInstant(keyName, instant);
                } else {
                        ContourThing **contourthing  = staticContourLst[ispartofstaticlist];
                        this->outlinesEnvironment->addInstantToThing    ( keyName , instant );
                        staticContourLst.erase( staticContourLst.begin()+ispartofstaticlist );
                }
        }

Here is the call graph for this function:

Here is the caller graph for this function:

void OutlineModelManager::clean

(

)

Definition at line 709 of file OutlineModelManager.cxx.

References actualInstantWrapping, InstantMembersNameList::clean(), PrefixMaxKeyGenerator::clear(), keyGenerator, and outlineGroups.

Referenced by ~OutlineModelManager().

        {
                /*axesEnvironment->clean();
                imagesSectionEnvironment->clean();
                imageSourceEnvironment->clean();
                outlinesEnvironment->clean();*/
                outlineGroups.clear();
                actualInstantWrapping->clean();
                keyGenerator.clear();
                //workSpace->clear();
        }

Here is the call graph for this function:

Here is the caller graph for this function:

bool OutlineModelManager::createAxe	(	std::string	aDescription,
		Instant *	theInstantData
	)

Definition at line 379 of file OutlineModelManager.cxx.

References addAxe(), and AxeThing::setDescription().

        {
                AxeThing * theAxe = new AxeThing ();
                theAxe->setDescription(aDescription);
                return addAxe(theAxe, theInstantData);
        }

Here is the call graph for this function:

std::string OutlineModelManager::createCopyContourOf	(	std::string	anExistingKName,
		std::vector< int > &	instantNoTouchData
	)

Definition at line 790 of file OutlineModelManager.cxx.

References createOutline(), ContourThing::getModel(), and getOutlineByKeyName().

Referenced by KernelManagerContour::createCopyContourOf().

        {
                manualBaseModel * manModelContour  = getOutlineByKeyName( anExistingKName )->getModel()->Clone();
                return createOutline( manModelContour, instantNoTouchData );
        }

Here is the call graph for this function:

Here is the caller graph for this function:

bool OutlineModelManager::createImageSection	(	std::string	aSecImageData,
		Instant *	theInstantData
	)

Definition at line 405 of file OutlineModelManager.cxx.

        {
                //imageSection = new ImageSectionThing(aSecImageData);
//              return addImageSection(new ImageSectionThing(aSecImageData), theInstantData);
                return NULL;
        }

bool OutlineModelManager::createImageSource	(	std::string	aSource,
		Instant *	theInstantData
	)

Definition at line 392 of file OutlineModelManager.cxx.

        {
//              imageSource = new ImageSourceThing(aSource);
                //return addImageSource(new ImageSourceThing(aSource), theInstantData);
                return NULL;//***********************************************************************************************
        }

std::string OutlineModelManager::createOutline	(	manualBaseModel *	model,
		std::vector< int >	theInstantData,
		std::string	aName = ""
	)

Definition at line 366 of file OutlineModelManager.cxx.

References addOutline(), and ContourThing::setName().

Referenced by createCopyContourOf(), KernelManagerContour::createOutline(), and KernelManagerContour::GetPoints().

        {
                ContourThing * theOutline = new ContourThing ( model );
                theOutline->setName(aName);
                return addOutline( theOutline, new Instant( &theInstantData ) );
        }

Here is the call graph for this function:

Here is the caller graph for this function:

ContourWorkspace * OutlineModelManager::createWorkSpace

(

)

Definition at line 85 of file OutlineModelManager.cxx.

References workSpace.

        {
                workSpace = new ContourWorkspace(this);
                return workSpace;
        }

bool OutlineModelManager::executeCommand	(	CommandObject *	theCommand,
		bool	fromRegistration = false
	)

Definition at line 123 of file OutlineModelManager.cxx.

Referenced by ContourWorkspace::executeCommand(), and executeCommandsQueue().

        {
                bool executedCom = true;
                //TODO**********************************************************************************************************************************************
                //Interpreting who is the one that executes the command

                //Modifiying the command in necessary for detaching interpreted information

                //If is an outline, sending the command to execute the specific command

                return executedCom;
        }

Here is the caller graph for this function:

bool OutlineModelManager::executeCommand_OutlineModel	(	std::string	outKName,
		CommandObject *	theCommand,
		bool	fromRegistration
	)

Definition at line 107 of file OutlineModelManager.cxx.

References ContourWorkspace::callRegisterCommand(), ContourThing::executeCommand(), ContourThing::getUndoCommandOf(), outlinesEnvironment, and workSpace.

        {
                ContourThing * theOutline = *outlinesEnvironment->getThingByName( outKName );
                if(!fromRegistration)
                {
                        CommandObject * undoCommand = theOutline->getUndoCommandOf( theCommand );
                        workSpace->callRegisterCommand(theCommand, undoCommand);
                }
                return theOutline->executeCommand( theCommand );
        }

Here is the call graph for this function:

bool OutlineModelManager::executeCommandsQueue	(	std::deque< CommandObject * >	executionQueue,
		bool	fromRegistration = false
	)

Definition at line 141 of file OutlineModelManager.cxx.

References executeCommand().

Referenced by ContourWorkspace::executeCommandsQueue().

        {
                bool executedComs = executionQueue.size()>0 ? true : false;
                while( executionQueue.size()>0 )
                {
                        CommandObject * aCmmand = executionQueue.front();
                        executedComs &= executeCommand(aCmmand, fromRegistration);
                        executionQueue.pop_front();
                }
                return executedComs;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector< NameWrapper * > OutlineModelManager::getActualInstantOutlines

(

)

Gets the outlines at an instant form the wrapping reference

Parameters

anInstant	The instant wondered to get outlines at
ifAnnotate	Indicates if it is needed to annotate the searched outlines

Returns

The vector to the outlines at the given instance

Gets the outlines at an instant form the outline's environment

Parameters

anInstant	The instant wondered to get outlines at
ifAnnotate	Indicates if it is needed to annotate the searched outlines

Returns

The vector to the outlines at the given instance

Definition at line 217 of file OutlineModelManager.cxx.

References actualInstantWrapping, and InstantMembersNameList::getOutlinesNamesVector().

Referenced by KernelManagerContour::getActualInstantOutlines().

        {
                return actualInstantWrapping->getOutlinesNamesVector();
        }

Here is the call graph for this function:

Here is the caller graph for this function:

AxeThing * OutlineModelManager::getAxeByKeyName

(

std::string

axeKName

)

Definition at line 611 of file OutlineModelManager.cxx.

References axesEnvironment.

        {
                return *axesEnvironment->getThingByName(axeKName);
        }

void OutlineModelManager::getConceptsInformation	(	std::vector< std::string > &	conceptNameVect,
		std::vector< int > &	conceptSizeVect
	)

Definition at line 686 of file OutlineModelManager.cxx.

References outlinesEnvironment.

        {
                if( outlinesEnvironment != NULL )
                {
                        //if (outlinesEnvironment->getNumberOfThings()>0)
                                outlinesEnvironment->getConceptsInformation(conceptNameVect, conceptSizeVect);
                }
        }

ContourWorkspace * OutlineModelManager::getContourWorkspace

(

)

Definition at line 700 of file OutlineModelManager.cxx.

References workSpace.

        {
                return workSpace;
        }

int OutlineModelManager::getGroupsCount

(

)

ImageSectionThing * OutlineModelManager::getImageSectionThingByKeyName

(

std::string

iSectionName

)

Definition at line 355 of file OutlineModelManager.cxx.

References imagesSectionEnvironment.

        {
                return *(imagesSectionEnvironment->getThingByName(iSectionName));
        }

ImageSourceThing * OutlineModelManager::getImageSourceThingByKeyName

(

std::string

iSeourceKName

)

Definition at line 345 of file OutlineModelManager.cxx.

References imageSourceEnvironment.

Referenced by KernelManagerContour::initializeEnvironment().

        {
                return *(imageSourceEnvironment->getThingByName(iSeourceKName));
        }

Here is the caller graph for this function:

Instant * OutlineModelManager::getInstant

(

)

Definition at line 601 of file OutlineModelManager.cxx.

References actualInstant.

Referenced by KernelManagerContour::getCurrentInstant().

        {
                return actualInstant;
        }

Here is the caller graph for this function:

std::vector< std::string > OutlineModelManager::GetLstNameThings

(

)

Gets the name of all outlines

Returns

The vector of strings of all outlines

Definition at line 279 of file OutlineModelManager.cxx.

References getOutlineInstants(), and outlinesEnvironment.

Referenced by KernelManagerContour::GetLstNameThings().

        {
                std::vector<std::string> kNamesVector;
                std::vector<ContourThing **> outlinesVector; //= new std::vector<ContourThing **>();
                std::vector<Instant *> lstInstants = getOutlineInstants();
                int i,sizeLstInstants = lstInstants.size();
                Instant *instant;
                for ( i=0 ; i<sizeLstInstants ; i++ )
                {
                        instant = lstInstants[i];
                        outlinesEnvironment->getThings( kNamesVector, outlinesVector, instant);
                } // for i
                return kNamesVector;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector< std::string > OutlineModelManager::GetLstNameThingsStatic

(

)

Definition at line 267 of file OutlineModelManager.cxx.

References staticContourLst.

Referenced by KernelManagerContour::GetLstNameThingsStatic().

        {
                std::vector<std::string> result;
                int i,sizeStaticContourLst =  staticContourLst.size();
                for ( i=0 ; i<sizeStaticContourLst ; i++ )
                {
                        ContourThing **contourthing  = staticContourLst[i];
                        result.push_back( (*contourthing)->getName() );
                }// for i
                return result;
        }

Here is the caller graph for this function:

ContourThing * OutlineModelManager::getOutlineByKeyName

(

std::string

outKName

)

Definition at line 335 of file OutlineModelManager.cxx.

References outlinesEnvironment.

Referenced by createCopyContourOf(), KernelManagerContour::deleteCModel(), KernelManagerContour::getOutlineByKeyName(), and getOutlinesFromGroup().

        {
                return *(outlinesEnvironment->getThingByName(outKName));
        }

Here is the caller graph for this function:

std::vector< Instant * > OutlineModelManager::getOutlineInstants

(

)

Definition at line 630 of file OutlineModelManager.cxx.

References outlinesEnvironment.

Referenced by GetLstNameThings().

        {
                return *outlinesEnvironment->getExistingInstants();
        }

Here is the caller graph for this function:

std::vector< Instant * > OutlineModelManager::getOutlineInstantsByName

(

std::string

thekName

)

Definition at line 621 of file OutlineModelManager.cxx.

References outlinesEnvironment.

        {
                return *outlinesEnvironment->getInstantsOfThing(thekName);
        }

std::vector< ContourThing ** > OutlineModelManager::getOutlinesAtInstant	(	Instant *	anInstant,
		bool	ifAnnotate = true
	)

Gets the outlines at an instant form the outline's environment

Parameters

anInstant	The instant wondered to get outlines at
ifAnnotate	Indicates if it is needed to annotate the searched outlines

Returns

The vector to the outlines at the given instance

Definition at line 244 of file OutlineModelManager.cxx.

References annotateOutlinesWrap(), outlinesEnvironment, and staticContourLst.

Referenced by KernelManagerContour::getOutlinesAtInstant(), KernelManagerContour::getOutlinesNameAtInstant(), and updateToActualInstant().

        {
                std::vector<std::string> kNamesVector;
                std::vector<ContourThing **> outlinesVector; //= new std::vector<ContourThing **>();
                outlinesEnvironment->getThings( kNamesVector, outlinesVector, anInstant);

//EED01
                int i,sizeStaticContourLst =  staticContourLst.size();
                for ( i=0 ; i<sizeStaticContourLst ; i++ )
                {
                        ContourThing **contourthing  = staticContourLst[i];
                        outlinesVector.push_back( contourthing );
                        kNamesVector.push_back( (*contourthing)->getName() );
                }// for i

                if (ifAnnotate)
                {
                        annotateOutlinesWrap(kNamesVector, outlinesVector);
                }
                return outlinesVector;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector< ContourThing * > OutlineModelManager::getOutlinesFromGroup

(

std::string

aGroupName

)

Gets the outlines at a specific form the outline's environment

Parameters

aGroupName

The name of the group containing the outlines names to get

Returns

The vector to the outlineGroups at the given group

Gets the outlines at a specific form the outline's environment

Parameters

aGroupName

The name of the group containing the outlines names to get

Returns

The vector to the outlines at the given group

Definition at line 300 of file OutlineModelManager.cxx.

References getOutlineByKeyName(), and outlineGroups.

        {
                std::vector<ContourThing *> outlinesVector;
                std::map< std::string,OutlineGroup * >::iterator iterP = outlineGroups.find(aGroupName);
                if ( iterP != outlineGroups.end() )
                {
                        std::vector<std::string> kNamesVector = iterP->second->getGroupOutlinesNames();
                        for(int i=0; i<kNamesVector.size();i++)
                        {
                                ContourThing * outlineI = getOutlineByKeyName(kNamesVector[i]);
                                outlinesVector.push_back(outlineI);
                        }
                }
                return outlinesVector;
        }

Here is the call graph for this function:

bool OutlineModelManager::includeAxeInstant	(	std::string	axeKName,
		Instant *	anInstantData
	)

Definition at line 654 of file OutlineModelManager.cxx.

References axesEnvironment.

        {
                return axesEnvironment->addInstantToThing( axeKName,anInstantData );
        }

bool OutlineModelManager::includeImageSectionInstant	(	std::string	imaKName,
		Instant *	anInstantData
	)

Definition at line 665 of file OutlineModelManager.cxx.

References imagesSectionEnvironment.

        {
                return imagesSectionEnvironment->addInstantToThing( imaKName,anInstantData );
        }

bool OutlineModelManager::includeImageSourceInstant	(	std::string	imaKName,
		Instant *	anInstantData
	)

Definition at line 676 of file OutlineModelManager.cxx.

References imageSourceEnvironment.

        {
                return imageSourceEnvironment->addInstantToThing( imaKName,anInstantData );
        }

bool OutlineModelManager::includeOutlineInstant	(	std::string	outKName,
		Instant *	anInstantData
	)

Definition at line 643 of file OutlineModelManager.cxx.

References outlinesEnvironment.

        {
                return outlinesEnvironment->addInstantToThing(outKName,anInstantData);
        }

int OutlineModelManager::IsPartOfStaticList

(

std::string

ss

)

Definition at line 440 of file OutlineModelManager.cxx.

References staticContourLst.

Referenced by ChangeContourOfList(), and KernelManagerContour::IsPartOfStaticList().

        {
                int iBack=-1;
                int i, size = staticContourLst.size();
                for( i=0 ; i<size ; i++ )
                {
                        ContourThing **contourthing  = staticContourLst[i];
                        if ((*contourthing)->getName() == ss)
                        {
                                iBack=i;
                        } // getName() == ss
                }
                return iBack;
        }

Here is the caller graph for this function:

void OutlineModelManager::removeAllOutlines

(

)

Definition at line 466 of file OutlineModelManager.cxx.

References outlinesEnvironment, removeOutline(), and staticContourLst.

Referenced by KernelManagerContour::removeAllOutlines().

        {
                //
                staticContourLst.clear();

                //
                std::vector< ContourThing **>  thingsVector;
                outlinesEnvironment->getThingsOfEnvironment( &thingsVector );
                int i,sizeThingVector = thingsVector.size();
                for(i=0;i<sizeThingVector;i++)
                {
                        ContourThing ** contourthing =  thingsVector[i];
                    removeOutline(  (*contourthing)->getName()   );
                }
        }

Here is the call graph for this function:

Here is the caller graph for this function:

void OutlineModelManager::removeOutline

(

std::string

ss

)

Definition at line 460 of file OutlineModelManager.cxx.

References outlinesEnvironment.

Referenced by KernelManagerContour::deleteCModel(), and removeAllOutlines().

        {
                        outlinesEnvironment->removeThing( ss );
        }

Here is the caller graph for this function:

void OutlineModelManager::SaveThingName	(	FILE *	pFile,
		FILE *	pFileData,
		std::string	nameThing
	)

Definition at line 796 of file OutlineModelManager.cxx.

References ContourThing::getModel(), and outlinesEnvironment.

Referenced by KernelManagerContour::SaveThingName().

        {
                std::vector< Instant * > *lstInstants;
                lstInstants = outlinesEnvironment->getInstantsOfThing( nameThing );
                Instant *instant = (*lstInstants)[0];
                std::vector<int> *vecInst =instant->getInstant();
                int i,sizeVecInst = vecInst->size();
                fprintf(pFile,"Instant ");
                for ( i=0 ; i<sizeVecInst ; i++ )
                {
                        fprintf(pFile,"%d ",(*vecInst)[i]);
                }
                fprintf(pFile,"\n");
                ContourThing *contourthing = *outlinesEnvironment->getThingByName(nameThing);
                contourthing->getModel()->Save(pFile);
                contourthing->getModel()->SaveData(pFileData);
        }

Here is the call graph for this function:

Here is the caller graph for this function:

bool OutlineModelManager::setAutomaticConcepts ( )

private

Definition at line 767 of file OutlineModelManager.cxx.

References axeConcept, axeDepthConcept, axesEnvironment, imagesSectionEnvironment, and outlinesEnvironment.

        {
                axeConcept = "Axe";
                axeDepthConcept = "Axe Depth";
                int axeC_size = 10;
                int axeDepthC_size = INT_MAX;

                bool allOK = axesEnvironment->addConcept(axeConcept, axeC_size);
                allOK &= imagesSectionEnvironment->addConcept(axeConcept, axeC_size);
                allOK &= outlinesEnvironment->addConcept(axeConcept, axeC_size);

                allOK &= imagesSectionEnvironment->addConcept(axeDepthConcept, axeDepthC_size);
                allOK &= outlinesEnvironment->addConcept(axeDepthConcept, axeDepthC_size);
/*
                allOK &= keyGenerator.addKeyThing("Axes", "Axe");
                allOK &= keyGenerator.addKeyThing("Image Sources", "Image source");
                allOK &= keyGenerator.addKeyThing("Image Sections", "Image section");
                allOK &= keyGenerator.addKeyThing("Outlines", "Outline");*/

                return allOK;
        }

void OutlineModelManager::setInstant

(

Instant *

newActualInstantData

)

Definition at line 595 of file OutlineModelManager.cxx.

References actualInstant, and updateToActualInstant().

Referenced by KernelManagerContour::setInstant().

        {
                actualInstant = newActualInstantData;
                updateToActualInstant();
        }

Here is the call graph for this function:

Here is the caller graph for this function:

bool OutlineModelManager::setUserConcepts

(

std::string

conceptsScript

)

Definition at line 159 of file OutlineModelManager.cxx.

References addUserConcept().

        {
                bool allOK = true;
                int endSub;
                std::string::size_type equalIndex = conceptsScript.find("=", 0);
                std::string::size_type nextIndex = 0;
                while( equalIndex != std::string::npos && allOK)
                {
            endSub = equalIndex;
                        std::string concept = conceptsScript.substr( 0, endSub );
                        conceptsScript.erase( 0, endSub+1 );
                        std::cout << "C: " << concept <<std::endl;
                        nextIndex = conceptsScript.find(";", 0);
                        std::string cSize;
                        if(nextIndex != std::string::npos)
                        {
                                endSub = nextIndex;
                                cSize = conceptsScript.substr( 0, endSub );
                                conceptsScript.erase( 0, endSub+1 );
                        }
                        else
                        {
                                endSub = conceptsScript.size();
                                cSize = conceptsScript.substr( 0, endSub );
                                conceptsScript.erase( 0, endSub );
                        }
                        int intReturn = atoi(cSize.c_str());
                        std::cout << "SZ: "<<intReturn <<std::endl;
                        equalIndex = conceptsScript.find("=", 0);
                        if( intReturn>0 )
                                allOK &= addUserConcept(concept, intReturn);
                        else
                                allOK = false;
                }
                return allOK;
        }

Here is the call graph for this function:

void OutlineModelManager::setWorkSpace

(

ContourWorkspace *

aWorkSpace

)

Definition at line 95 of file OutlineModelManager.cxx.

References workSpace.

        {
                workSpace = aWorkSpace;
        }

void OutlineModelManager::updateToActualInstant ( )

private

Definition at line 724 of file OutlineModelManager.cxx.

References actualInstant, and getOutlinesAtInstant().

Referenced by setInstant().

        {
                Instant * longInstant = actualInstant;
                /*Instant * mediumInstant = new Instant();
                Instant * shortInstant = new Instant();
                std::vector<int>* theInstant = longInstant->getInstant();
                for(int i=1; i<theInstant->size(); i++)
                {
                        if (i>=2)
                                shortInstant->addConcept( (*theInstant)[i] );
                        mediumInstant->addConcept( (*theInstant)[i] );
                }

                //getting the sourceAtInstant
                std::vector<std::string> kSourceVector;
                std::vector<ImageSourceThing **> imSourceVector;
                imageSourceEnvironment->getThings(kSourceVector, imSourceVector, shortInstant);
                annotateActualSourceImageWrap(kSourceVector[0], (**imSourceVector[0]).getSourceImage());

        //getting the aAxeAtInstant
                std::vector<std::string> kAxeVector;
                std::vector<AxeThing **> axesVector;
                axesEnvironment->getThings(kAxeVector, axesVector, mediumInstant);
                if ( !kAxeVector.empty() )
                        annotateActualAxeWrap(kAxeVector[0], (**axesVector[0]).getDescription());

                //getting the sectionAtInstant
                std::vector<std::string> kSectionVector;
                std::vector<ImageSectionThing **> imSectionVector;
                imagesSectionEnvironment->getThings(kSectionVector, imSectionVector, longInstant); if ( !kSectionVector.empty() )
            //annotateActualSectionImageWrap(kSectionVector[0], (**imSectionVector[0]).getImageData());
                */

                //getting the outlines

                std::vector<ContourThing ** > vect = getOutlinesAtInstant( longInstant );

        }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

std::string OutlineModelManager::actualGruopID

private

Definition at line 426 of file OutlineModelManager.h.

Instant* OutlineModelManager::actualInstant

private

Definition at line 495 of file OutlineModelManager.h.

Referenced by getInstant(), OutlineModelManager(), setInstant(), updateToActualInstant(), and ~OutlineModelManager().

InstantMembersNameList* OutlineModelManager::actualInstantWrapping

private

Definition at line 481 of file OutlineModelManager.h.

Referenced by annotateActualAxeWrap(), annotateActualOutlineWrap(), annotateActualSectionImageWrap(), annotateActualSourceImageWrap(), annotateOutlinesWrap(), annotateOutlineWrap(), clean(), getActualInstantOutlines(), OutlineModelManager(), and ~OutlineModelManager().

std::string OutlineModelManager::axeConcept

private

Definition at line 492 of file OutlineModelManager.h.

Referenced by setAutomaticConcepts().

std::string OutlineModelManager::axeDepthConcept

private

Definition at line 493 of file OutlineModelManager.h.

Referenced by setAutomaticConcepts().

SomeEnvironment<AxeThing *>* OutlineModelManager::axesEnvironment

private

Definition at line 436 of file OutlineModelManager.h.

Referenced by addAxe(), addUserConcept(), getAxeByKeyName(), includeAxeInstant(), OutlineModelManager(), and setAutomaticConcepts().

bool OutlineModelManager::changeSourceImage

private

Definition at line 486 of file OutlineModelManager.h.

Referenced by OutlineModelManager().

int OutlineModelManager::counterIdKey

private

Definition at line 488 of file OutlineModelManager.h.

Referenced by addOutline(), and OutlineModelManager().

SomeEnvironment<ImageSourceThing *>* OutlineModelManager::imageSourceEnvironment

private

Definition at line 456 of file OutlineModelManager.h.

Referenced by addImageSource(), addUserConcept(), getImageSourceThingByKeyName(), includeImageSourceInstant(), and OutlineModelManager().

SomeEnvironment<ImageSectionThing *>* OutlineModelManager::imagesSectionEnvironment

private

Definition at line 446 of file OutlineModelManager.h.

Referenced by addImageSection(), addUserConcept(), getImageSectionThingByKeyName(), includeImageSectionInstant(), OutlineModelManager(), and setAutomaticConcepts().

PrefixMaxKeyGenerator OutlineModelManager::keyGenerator

private

Definition at line 489 of file OutlineModelManager.h.

Referenced by addAxe(), addImageSection(), addImageSource(), addOutline(), clean(), and OutlineModelManager().

std::map< std::string,OutlineGroup * > OutlineModelManager::outlineGroups

private

Definition at line 471 of file OutlineModelManager.h.

Referenced by addOutlinesGroup(), clean(), and getOutlinesFromGroup().

SomeEnvironment<ContourThing *>* OutlineModelManager::outlinesEnvironment

private

Definition at line 466 of file OutlineModelManager.h.

Referenced by addOutline(), addUserConcept(), ChangeContourOfList(), executeCommand_OutlineModel(), getConceptsInformation(), GetLstNameThings(), getOutlineByKeyName(), getOutlineInstants(), getOutlineInstantsByName(), getOutlinesAtInstant(), includeOutlineInstant(), OutlineModelManager(), removeAllOutlines(), removeOutline(), SaveThingName(), and setAutomaticConcepts().

std::vector<ContourThing **> OutlineModelManager::staticContourLst

private

Definition at line 498 of file OutlineModelManager.h.

Referenced by ChangeContourOfList(), GetLstNameThingsStatic(), getOutlinesAtInstant(), IsPartOfStaticList(), and removeAllOutlines().

ContourWorkspace* OutlineModelManager::workSpace

private

Definition at line 476 of file OutlineModelManager.h.

Referenced by createWorkSpace(), executeCommand_OutlineModel(), getContourWorkspace(), OutlineModelManager(), setWorkSpace(), and ~OutlineModelManager().

---

The documentation for this class was generated from the following files:

• /home/davila/Creatis/All/creatools_source/creaContours/lib/kernel_ManagerContour_NDimensions/OutlineModelManager.h
• /home/davila/Creatis/All/creatools_source/creaContours/lib/kernel_ManagerContour_NDimensions/OutlineModelManager.cxx