1 /*=========================================================================
7 =========================================================================*/
9 /* ---------------------------------------------------------------------
11 * Copyright (c) CREATIS-LRMN (Centre de Recherche en Imagerie Medicale)
12 * Authors : Eduardo Davila, Laurent Guigues, Jean-Pierre Roux
14 * This software is governed by the CeCILL-B license under French law and
15 * abiding by the rules of distribution of free software. You can use,
16 * modify and/ or redistribute the software under the terms of the CeCILL-B
17 * license as circulated by CEA, CNRS and INRIA at the following URL
18 * http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
19 * or in the file LICENSE.txt.
21 * As a counterpart to the access to the source code and rights to copy,
22 * modify and redistribute granted by the license, users are provided only
23 * with a limited warranty and the software's author, the holder of the
24 * economic rights, and the successive licensors have only limited
27 * The fact that you are presently reading this means that you have had
28 * knowledge of the CeCILL-B license and that you accept its terms.
29 * ------------------------------------------------------------------------ */
33 * \brief Class bbtk::wxVtkSceneManager .
36 #include "wxVtkSceneManager.h"
38 #include <vtkPolygon.h>
39 #include <vtkUnstructuredGrid.h>
43 //=========================================================================
44 wxVtkSceneManager::wxVtkSceneManager(wxGEditorTabPanel *parent,
45 wxVtk3DBaseView *baseView, int idManager) {
46 _cbName = "ComplexBoxName";
47 _cbPackageName = "PackageName";
48 _Author = "Author ??";
50 _Description = "Description ??";
54 _idManager = idManager;
56 _startDragging = false;
57 _isComplexBox = false;
59 if (_baseView != NULL) {
62 "RaC-EED 21-06-2010 %p wxVtkSceneManager::wxVtkSceneManager If you comment this line, the drag and drop functionnality is not initialized.\n",
65 _baseView->GetWxVTKRenderWindowInteractor()->SetDropTarget((wxDropTarget*)parent);
69 _worldState = NOTHING_HAPPENS;
70 registerController(this);
73 _idConnectionInCreation = -1;
78 //=========================================================================
80 void wxVtkSceneManager::disconnectDrop() {
81 printf("EED %p ~wxVtkSceneManager::disconnectDrop()\n", this);
82 //EED02JUIN2010 _baseView->GetWxVTKRenderWindowInteractor()->SetDropTarget(NULL);
83 // _baseView->GetWxVTKRenderWindowInteractor()->SetDropTarget( new tmpClasswxTextDropTarget() );
86 //=========================================================================
88 wxVtkSceneManager::~wxVtkSceneManager() {
90 printf("EED %p ~wxVtkSceneManager()\n", this);
95 //=========================================================================
97 void wxVtkSceneManager::configureBaseView() {
98 printf("EED wxVtkSceneManager::configureBaseView 0\n");
99 vtkInteractorStyleBaseView2D *interactorstylebaseview =
100 vtkInteractorStyleBaseView2D::New();
102 _baseView->SetInteractorStyleBaseView(interactorstylebaseview);
104 // Important to activate the 2D interaction system
105 wxVTKRenderWindowInteractor *iren =
106 _baseView->GetWxVTKRenderWindowInteractor();
107 interactorstylebaseview->SetInteractor(iren);
108 iren->SetInteractorStyle(interactorstylebaseview);
109 interactorstylebaseview->SetwxVtkBaseView(_baseView);
111 _baseView->GetRenderer()->GetActiveCamera()->ParallelProjectionOn();
112 _baseView->GetRenderer()->ResetCamera(-100, 100, -100, 100, 800, 1100);
114 _baseView->GetRenderer()->SetBackground(0.9, 0.9, 0.9);
115 _baseView->GetRenderer()->GradientBackgroundOn();
116 _baseView->Refresh();
119 _textActor = vtkTextActor3D::New();
120 _textActor->SetPosition(-9999, -9999, 900);
121 _textActor->SetInput("<void>");
122 _textActor->GetTextProperty()->SetFontSize(60);
123 _textActor->GetTextProperty()->BoldOn();
124 _textActor->GetTextProperty()->SetColor(PORTTEXT_NH_R, PORTTEXT_NH_G,
127 _baseView->GetRenderer()->AddActor(_textActor);
129 // Actor Fill_Port_Text
136 vtkPolygon *aPolygon = vtkPolygon::New();
137 _fillObjectActor = vtkActor::New();
139 _pts = vtkPoints::New();
141 double w = 100, h = 10, b = h / 15, t = 3;
142 _pts->SetNumberOfPoints(21);
143 _pts->InsertPoint(0, xInic + w * 0.33 - t / 2, yInic, zInic);
144 _pts->InsertPoint(1, xInic + w * 0.33, yInic - t, zInic);
145 _pts->InsertPoint(2, xInic + w * 0.33 + t / 2, yInic, zInic);
146 _pts->InsertPoint(3, xInic + w * 0.33 + t / 2, yInic, zInic);
147 _pts->InsertPoint(4, xInic + w - b * 4, yInic + b * 0, zInic);
149 _pts->InsertPoint(5, xInic + w - b * 4, yInic + b * 0, zInic);
150 _pts->InsertPoint(6, xInic + w - b * 2, yInic + b * 1, zInic);
151 _pts->InsertPoint(7, xInic + w - b * 1, yInic + b * 2, zInic);
152 _pts->InsertPoint(8, xInic + w - b * 0, yInic + b * 4, zInic);
154 _pts->InsertPoint(9, xInic + w - b * 0, yInic + h - b * 4, zInic);
155 _pts->InsertPoint(10, xInic + w - b * 1, yInic + h - b * 2, zInic);
156 _pts->InsertPoint(11, xInic + w - b * 2, yInic + h - b * 1, zInic);
157 _pts->InsertPoint(12, xInic + w - b * 4, yInic + h - b * 0, zInic);
159 _pts->InsertPoint(13, xInic + b * 4, yInic + h - b * 0, zInic);
160 _pts->InsertPoint(14, xInic + b * 2, yInic + h - b * 1, zInic);
161 _pts->InsertPoint(15, xInic + b * 1, yInic + h - b * 2, zInic);
162 _pts->InsertPoint(16, xInic + b * 0, yInic + h - b * 4, zInic);
164 _pts->InsertPoint(17, xInic + b * 0, yInic + b * 4, zInic);
165 _pts->InsertPoint(18, xInic + b * 1, yInic + b * 2, zInic);
166 _pts->InsertPoint(19, xInic + b * 2, yInic + b * 1, zInic);
167 _pts->InsertPoint(20, xInic + b * 4, yInic + b * 0, zInic);
169 aPolygon->GetPointIds()->SetNumberOfIds(21);
170 for (int i = 0; i < 21; i++) {
171 aPolygon->GetPointIds()->SetId(i, i);
174 vtkUnstructuredGrid *aPolygonGrid = vtkUnstructuredGrid::New();
175 aPolygonGrid->Allocate(1, 1);
176 aPolygonGrid->InsertNextCell(aPolygon->GetCellType(),
177 aPolygon->GetPointIds());
178 aPolygonGrid->SetPoints(_pts);
179 _aPolygonMapper = vtkDataSetMapper::New();
180 _aPolygonMapper->SetInput(aPolygonGrid);
181 _fillObjectActor->SetMapper(_aPolygonMapper);
182 _fillObjectActor->GetProperty()->SetColor(PORTFILL_NH_R, PORTFILL_NH_G,
184 _fillObjectActor->GetProperty()->SetOpacity(0);
185 _aPolygonMapper->Modified();
187 _baseView->GetRenderer()->AddActor(_fillObjectActor);
188 printf("EED wxVtkSceneManager::configureBaseView 1\n");
191 //=========================================================================
193 std::string wxVtkSceneManager::generateANewNameForABox() {
194 std::stringstream boxname;
195 if (_numBoxes < 10) {
196 boxname << "Box0" << _numBoxes;
198 boxname << "Box" << _numBoxes;
201 return boxname.str();
204 //=========================================================================
206 std::string wxVtkSceneManager::findANewNameForABox() {
207 std::string boxname = generateANewNameForABox();
209 while (boxExist(boxname) == true) {
210 boxname = generateANewNameForABox();
216 //=========================================================================
217 void wxVtkSceneManager::configGBlackBox(int idBox, double xIn, double yIn,
218 double zIn, std::string name, bool boxExecutable, double xEn,
219 double yEn, double zEn) {
220 GObjectController *cont = _controllers[idBox];
221 GBlackBoxModel *bbmod = (GBlackBoxModel*) cont->getModel();
222 bbmod->setBBTKName(name);
223 bbmod->setInicPoint(xIn, yIn, zIn);
224 bbmod->setFinalPoint(xEn, yEn, zEn);
225 bbmod->setExecutable(boxExecutable);
227 bbmod->notifyObservers(_idManager);
231 //=========================================================================
233 int wxVtkSceneManager::createGBlackBox(int x, int y, std::string packageName,
234 std::string boxType) {
235 _worldState = NOTHING_HAPPENS;
236 //EED int windowWidth = _baseView->GetRenWin()->GetSize()[0];
237 int windowHeight = _baseView->GetRenWin()->GetSize()[1];
239 int type = GBLACKBOX;
241 //Create the MVC Objects
245 (GBlackBoxModel*) GObjectsMVCFactory::getInstance()->createGObjectModel(
247 vtkGObjectView *view =
248 GObjectsMVCFactory::getInstance()->createGObjectView(type);
249 GObjectController* controller =
250 GObjectsMVCFactory::getInstance()->createGObjectController(type);
252 BlackBoxDescriptor::Pointer descriptor =
253 GObjectsMVCFactory::getInstance()->getBlackBoxDescriptor(
254 packageName, boxType);
256 //Prepares the initial model
257 //The coordinates obtained are the following. Top-Left:x=0,y=0 Bottom-Right:x=width,y=height
260 double yy = windowHeight - y;
262 //z value is not important yet, because it is only used a parallel projection
264 _baseView->TransCoordScreenToWorld(xx, yy, zz);
265 model->setInicPoint(xx, yy, zz);
267 std::stringstream stream;
269 std::string newBoxName;
270 newBoxName = findANewNameForABox();
272 stream << newBoxName;
274 std::string arraystring = stream.str();
276 model->setBBTKName(arraystring);
277 model->setBBTKType(boxType);
278 model->setBBTKPackage(packageName);
280 model->addObserver(view);
281 model->addObserver(this);
283 //Iterate and create the input ports
284 std::map<std::string, BlackBoxInputDescriptor*> descriptorInMap =
285 descriptor->GetInputDescriptorMap();
286 std::map<std::string, BlackBoxInputDescriptor*>::iterator itInput;
289 for (itInput = descriptorInMap.begin(); itInput != descriptorInMap.end(); ++itInput) {
290 BlackBoxInputDescriptor *desc = itInput->second;
291 createGInputPort(GINPUTPORT, i, model, desc);
295 //Iterate and create the output ports
296 std::map<std::string, BlackBoxOutputDescriptor*> descriptorOutMap =
297 descriptor->GetOutputDescriptorMap();
298 std::map<std::string, BlackBoxOutputDescriptor*>::iterator itOutput;
301 for (itOutput = descriptorOutMap.begin(); itOutput
302 != descriptorOutMap.end(); ++itOutput) {
303 BlackBoxOutputDescriptor *desc = itOutput->second;
304 createGOutputPort(GOUTPUTPORT, i, model, desc);
308 //Associates the view with the correspondent renderer and the model.
309 //(NOTE: Refresh is only made by the view)
310 view->setModel(model);
311 view->setBaseView(_baseView);
312 view->initVtkObjects();
314 //Associates the controller with the correspondent model and view
315 controller->setModelAndView(model, view);
317 //Resgiter change to the observers of the actual model
318 model->notifyObservers(_idManager);
320 int newId = addObjectController(controller);
326 //=========================================================================
328 int wxVtkSceneManager::createGComplexBoxInputPort(std::string inputName) {
329 //EED int windowWidth=_baseView->GetRenWin()->GetSize()[0];
330 int windowHeight = _baseView->GetRenWin()->GetSize()[1];
332 int type = GCOMPLEXINPUTPORT;
334 //Create the MVC Objects
338 (GComplexBoxPortModel*) GObjectsMVCFactory::getInstance()->createGObjectModel(
340 vtkGObjectView *view =
341 GObjectsMVCFactory::getInstance()->createGObjectView(type);
342 GObjectController* controller =
343 GObjectsMVCFactory::getInstance()->createGObjectController(type);
345 //Prepares the initial model
348 double yy = windowHeight - 5;
350 //z value is not important yet, because it is only used a parallel projection
352 printf("EED wxVtkSceneManager::createGComplexBoxInputPort 900-450\n");
354 _baseView->TransCoordScreenToWorld(xx, yy, zz);
355 model->setInicPoint(xx, yy, zz);
357 model->setBBTKName(inputName);
358 model->setBBTKType("ComplexInputPort");
359 model->setComplexPortType(type);
361 model->addObserver(view);
362 model->addObserver(this);
364 //create the output port
365 GPortController* portController = createGPort(GOUTPUTPORT, inputName,
366 "ComplexInputPort", 0, model);
367 model->addOutputPort((GPortModel*) portController->getModel());
369 //Associates the view with the correspondent renderer and the model.
370 //(NOTE: Refresh is only made by the view)
371 view->setModel(model);
372 view->setBaseView(_baseView);
373 view->initVtkObjects();
375 //Associates the controller with the correspondent model and view
376 controller->setModelAndView(model, view);
378 //Resgiter change to the observers of the actual model
379 model->notifyObservers(_idManager);
381 int newId = addObjectController(controller);
385 //=========================================================================
387 int wxVtkSceneManager::createGComplexBoxOutputPort(std::string outputName) {
388 //EED int windowWidth=_baseView->GetRenWin()->GetSize()[0];
389 int windowHeight = _baseView->GetRenWin()->GetSize()[1];
391 int type = GCOMPLEXOUTPUTPORT;
393 //Create the MVC Objects
397 (GComplexBoxPortModel*) GObjectsMVCFactory::getInstance()->createGObjectModel(
399 vtkGObjectView *view =
400 GObjectsMVCFactory::getInstance()->createGObjectView(type);
401 GObjectController *controller =
402 GObjectsMVCFactory::getInstance()->createGObjectController(type);
404 //Prepares the initial model
407 double yy = windowHeight - 5;
409 //z value is not important yet, because it is only used a parallel projection
412 printf("EED wxVtkSceneManager::createGComplexBoxOutputPort 900-450\n");
414 _baseView->TransCoordScreenToWorld(xx, yy, zz);
415 model->setInicPoint(xx, yy, zz);
417 model->setBBTKName(outputName);
418 model->setBBTKType("ComplexOutputPort");
419 model->setComplexPortType(type);
421 model->addObserver(view);
422 model->addObserver(this);
424 //create the output port
425 GPortController* portController = createGPort(GINPUTPORT, outputName,
426 "ComplexInputPort", 0, model);
427 model->addInputPort((GPortModel*) portController->getModel());
429 //Associates the view with the correspondent renderer and the model.
430 //(NOTE: Refresh is only made by the view)
431 view->setModel(model);
432 view->setBaseView(_baseView);
433 view->initVtkObjects();
435 //Associates the controller with the correspondent model and view
436 controller->setModelAndView(model, view);
438 //Resgiter change to the observers of the actual model
439 model->notifyObservers(_idManager);
441 int newId = addObjectController(controller);
445 //=========================================================================
447 int wxVtkSceneManager::createGInputPort(int portType, int posinBox,
448 GBoxModel *blackBox, BlackBoxInputDescriptor *desc) {
449 GPortController* portController = createGPort(portType, desc->GetName(),
450 desc->GetTypeName(), posinBox, blackBox);
451 blackBox->addInputPort((GPortModel*) portController->getModel());
452 return portController->getId();
455 //=========================================================================
457 int wxVtkSceneManager::createGOutputPort(int portType, int posinBox,
458 GBoxModel *blackBox, BlackBoxOutputDescriptor *desc) {
459 GPortController* portController = createGPort(portType, desc->GetName(),
460 desc->GetTypeName(), posinBox, blackBox);
461 blackBox->addOutputPort((GPortModel*) portController->getModel());
462 return portController->getId();
465 //=========================================================================
467 GPortController* wxVtkSceneManager::createGPort(int portType,
468 std::string bbtkName, std::string bbtkType, int posInBox,
469 GBoxModel *blackBox) {
472 //Create the MVC Objects
475 (GPortModel*) GObjectsMVCFactory::getInstance()->createGObjectModel(
477 vtkGObjectView *view =
478 GObjectsMVCFactory::getInstance()->createGObjectView(type);
479 GObjectController* controller =
480 GObjectsMVCFactory::getInstance()->createGObjectController(type);
482 model->registerInBox(blackBox, portType, posInBox);
484 model->setBBTKType(bbtkType);
485 model->setBBTKName(bbtkName);
487 model->addObserver(view);
488 model->addObserver(this);
490 //Associates the view with the correspondent renderer and the model.
491 //(NOTE: Refresh is only made by the view)
492 view->setModel(model);
493 view->setBaseView(_baseView);
494 view->initVtkObjects();
496 //Associates the controller with the correspondent model and view
497 controller->setModelAndView(model, view);
499 model->notifyObservers(_idManager);
501 addObjectController(controller);
503 return (GPortController*) controller;
506 //=========================================================================
508 int wxVtkSceneManager::createGConnector(GPortModel* startPort) {
509 int type = GCONNECTOR;
511 manualConnectorContourController* manContourControl =
512 new manualConnectorContourController();
513 manualConnectorContourView* manContourView =
514 new manualConnectorContourView();
515 manualContourModel* manContourModel = new manualContourModel();
517 GConnectorController* connectorcontroller = new GConnectorController();
518 GConnectorModel* connectorModel = new GConnectorModel();
519 vtkGConnectorView* connectorView = new vtkGConnectorView();
520 connectorModel->setGObjectType(type);
522 manContourModel->SetCloseContour(false);
523 connectorModel->setStartPort(startPort);
525 manContourView->SetModel(manContourModel);
526 manContourView->SetWxVtkBaseView(_baseView);
527 manContourView->SetRange(0.5);
528 manContourView->SetZ(900);
530 manContourView->SetColorNormalContour(0, 0, 1);
531 manContourView->SetColorEditContour(0.5, 0.5, 0.5);
532 manContourView->SetColorSelectContour(1, 0.8, 0);
533 manContourView->SetWidthLine(1);
534 manContourView->SetShowText(false);
536 manContourControl->SetModelView(manContourModel, manContourView);
538 manContourControl->CreateNewManualContour();
540 manContourView->RefreshContour();
543 connectorModel->getInicPoint(x, y, z);
545 manContourControl->SetState(1);
546 manContourModel->SetCloseContour(false);
548 manContourModel->AddPoint(x, y, z);
549 manContourView->AddPoint();
551 manContourModel->AddPoint(x, y, z);
552 manContourView->AddPoint();
554 int bak = manContourControl->GetNumberOfPointsManualContour() - 1;
555 manContourControl->_bakIdPoint = bak;
556 manContourView->Refresh();
558 manContourControl->SetMoving(false);
560 connectorcontroller->setModelAndView(connectorModel, connectorView);
562 int newId = addObjectController(connectorcontroller);
564 connectorcontroller->setManualContourController(manContourControl);
565 connectorModel->setManualContourModel(manContourModel);
566 connectorView->setManualContourView(manContourView);
567 connectorView->setModel(connectorModel);
568 connectorView->setBaseView(_baseView);
570 connectorModel->addObserver(connectorView);
571 connectorModel->addObserver(this);
576 //=========================================================================
578 void wxVtkSceneManager::registerController(InteractorStyleMaracas *param) {
579 vtkInteractorStyleBaseView
580 * baseViewControlManager =
581 (vtkInteractorStyleBaseView*) _baseView->GetInteractorStyleBaseView();
582 baseViewControlManager->AddInteractorStyleMaracas(param);
585 //=========================================================================
587 void wxVtkSceneManager::unregisterController(InteractorStyleMaracas *param) {
588 vtkInteractorStyleBaseView
589 * baseViewControlManager =
590 (vtkInteractorStyleBaseView*) _baseView->GetInteractorStyleBaseView();
591 baseViewControlManager->RemoveInteractorStyleMaracas(param);
594 //=========================================================================
596 vtkRenderer* wxVtkSceneManager::getRenderer() {
597 return _baseView->GetRenderer();
600 //=========================================================================
602 vtkRenderWindow* wxVtkSceneManager::getRenderWindow() {
603 return _baseView->GetRenWin();
605 //=========================================================================
608 //=========================================================================
609 int wxVtkSceneManager::GetIndexInSelected(int idControler) {
611 for (int i = 0; i < (int) _selectedObjects.size(); i++) {
612 if (_selectedObjects[i] == idControler) {
619 //=========================================================================
621 void wxVtkSceneManager::update(int idController, int command) {
623 if (command != NO_COMMAND) {
624 if (command == ADD_TO_SELECTED) {
625 //EEDBorrame GObjectController* cont = _controllers[idController];
627 if (GetIndexInSelected(idController) == -1) {
628 _selectedObjects.push_back(idController);
632 // bool foundID=false;
633 // for (int i=0; i<(int)_selectedObjects.size() && foundID==false; i++)
635 // if(_selectedObjects[i]==idController)
642 // _selectedObjects.push_back(idController);
645 } else if (command == REMOVE_FROM_SELECTED) {
646 int index = GetIndexInSelected(idController);
648 _selectedObjects.erase(_selectedObjects.begin() + index);
650 } else if (command == INIT_CREATION_CONTOUR) {
651 _worldState = INIT_CREATION_CONTOUR;
652 GObjectController* cont = _controllers[idController];
653 GPortModel* startOutputPort = (GPortModel*) cont->getModel();
655 // The last one is the controller of the connector
656 std::map<int, GObjectController*>::iterator it2;
658 for (it2 = _controllers.begin(); it2 != _controllers.end(); ++it2) {
659 GObjectController *cont = it2->second;
660 if (cont->getGObjectType() == GPORT) {
661 GPortModel* port = (GPortModel*) cont->getModel();
662 if (port->getPortType() == GINPUTPORT) {
663 cont->SetActive(true);
665 cont->getView()->setState(NOTHING_HAPPENS);
666 cont->getModel()->notifyObservers(_idManager);
667 cont->SetActive(false);
670 cont->getView()->setState(NOTHING_HAPPENS);
671 cont->getModel()->notifyObservers(_idManager);
672 cont->SetActive(false);
675 _selectedObjects.clear();
676 _idConnectionInCreation = createGConnector(startOutputPort);
677 } else if (command == FIN_CREATION_CONTOUR && _worldState
678 == INIT_CREATION_CONTOUR) {
679 _worldState = NOTHING_HAPPENS;
680 //int id = _controllers.size()-1;
681 GObjectController *cont = _controllers[_idConnectionInCreation];
682 GConnectorModel *modelContour = (GConnectorModel*) cont->getModel();
683 GObjectController *finPort = _controllers[idController];
685 if (finPort->getGObjectType() == GPORT) {
686 GPortModel* modelPort = (GPortModel*) finPort->getModel();
687 modelContour->setEndPort(modelPort);
690 manualConnectorContourController
692 ((GConnectorController*) cont)->getManualContourController();
693 manualConnectorContourView
695 (manualConnectorContourView*) manCont->GetManualViewBaseContour();
698 std::map<int, GObjectController*>::iterator it2;
700 for (it2 = _controllers.begin(); it2 != _controllers.end(); ++it2) {
701 GObjectController *cont = it2->second;
702 if (cont->getView() != NULL) {
703 cont->getView()->setState(NOTHING_HAPPENS);
704 cont->getModel()->notifyObservers(_idManager);
706 cont->SetActive(true);
714 //=========================================================================
716 bool wxVtkSceneManager::OnMouseMove() {
718 bool okStatusMessage = false;
719 bool okPortMessage = false;
720 wxVTKRenderWindowInteractor *wxVTKiren;
722 = _vtkInteractorStyleBaseView->GetWxVtk3DBaseView()->GetWxVTKRenderWindowInteractor();
723 wxVTKiren->GetEventPosition(X, Y);
725 if (_worldState == DRAG_OBJECTS) {
726 for (int i = 0; i < (int) _selectedObjects.size(); i++) {
727 int id = _selectedObjects[i];
728 GObjectController* cont = _controllers[id];
729 if (_startDragging) {
730 cont->getView()->setStartDragging(true);
732 cont->getView()->moveObject(X, Y);
733 cont->getView()->setState(DRAG);
734 cont->getModel()->notifyObservers(_idManager);
737 std::map<int, GObjectController*>::iterator it;
739 for (it = _controllers.begin(); it != _controllers.end(); ++it) {
740 GObjectController *desc = it->second;
741 if (desc->getGObjectType() == GCONNECTOR) {
742 vtkGConnectorView* vconn = (vtkGConnectorView*) desc->getView();
743 vconn->updateStartEndPoints();
747 _startDragging = false;
749 } else if (_worldState == NOTHING_HAPPENS || _worldState
750 == INIT_CREATION_CONTOUR) {
751 std::map<int, GObjectController*>::iterator it;
753 for (it = _controllers.begin(); it != _controllers.end(); ++it) {
754 GObjectController *desc = it->second;
755 int type = desc->getGObjectType();
756 int state = desc->getView()->getState();
757 desc->getModel()->getCenter(px, py, pz);
759 if (state == HIGHLIGHTED) {
760 okStatusMessage = true;
761 updateStatusBar(desc->getStatusText());
762 if (type == GBLACKBOX) {
763 GBlackBoxModel *mod = (GBlackBoxModel*) desc->getModel();
764 _parent->displayBlackBoxInfo(mod->getBBTKPackage(),
769 okPortMessage = true;
771 _textActor->SetInput(desc->getStatusText().c_str());
772 _textActor->SetScale(0.1);
773 _textActor->SetPosition(px - 25, py + 1, pz + 2);
778 _fillObjectActor->SetScale(1);
779 _fillObjectActor->GetProperty()->SetOpacity(0.50);
780 _fillObjectActor->SetPosition(px, py, 1);
781 _aPolygonMapper->Modified();
784 } // for controllers it
787 if (okStatusMessage == false) {
791 if (okPortMessage == false) {
792 _textActor->SetScale(0.0001);
793 _fillObjectActor->SetScale(0.0001);
798 //=========================================================================
800 bool wxVtkSceneManager::OnLeftButtonDown() {
802 if (_worldState == INIT_CREATION_CONTOUR) {
803 bool isOverPort = false;
804 std::map<int, GObjectController*>::iterator it;
805 for (it = _controllers.begin(); it != _controllers.end() && isOverPort
807 GObjectController *desc = it->second;
808 if (desc->getGObjectType() == GPORT) {
809 GPortModel *portmod = (GPortModel*) desc->getModel();
810 vtkGObjectView *portView = desc->getView();
811 if (portmod->getPortType() == GINPUTPORT
812 && portView->getState() == HIGHLIGHTED) {
818 if (isOverPort == false) {
820 UnSelectBlackBoxes();
823 } else { //_worldState
825 _worldState = DRAG_OBJECTS;
826 _startDragging = true;
829 _vtkInteractorStyleBaseView->GetInteractor()->GetShiftKey();
831 _vtkInteractorStyleBaseView->GetInteractor()->GetControlKey();
832 ctrlkey = ctrlkey + shiftkey;
834 GObjectController *cont = GetGBlackBoxControlerPointedByMouse();
836 if (GetGBlackBoxControlerPointedByMouse() != NULL) {
837 int state = cont->getView()->getState();
838 if ((ctrlkey == 0) && (state == HIGHLIGHTED)) {
839 UnSelectBlackBoxes();
842 for (int i = 0; i < (int) _selectedObjects.size(); i++) {
843 int id = _selectedObjects[i];
844 GObjectController* cont = _controllers[id];
845 cont->getView()->setState(DRAG);
846 cont->getModel()->notifyObservers(_idManager);
849 } // if _selectedObjects.size
855 //=========================================================================
857 bool wxVtkSceneManager::OnLeftButtonUp() {
858 if (_worldState == DRAG_OBJECTS) {
859 _worldState = NOTHING_HAPPENS;
861 for (int i = 0; i < (int) _selectedObjects.size(); i++) {
862 int id = _selectedObjects[i];
863 GObjectController* cont = _controllers[id];
864 cont->getView()->setState(SELECTED);
865 cont->getModel()->notifyObservers(_idManager);
871 //=========================================================================
872 void wxVtkSceneManager::CancelConnection() {
873 if (_worldState == INIT_CREATION_CONTOUR) {
874 _worldState = NOTHING_HAPPENS;
875 //int lastId = _controllers.size()-1;
877 GConnectorController *connector =
878 (GConnectorController*) _controllers[_idConnectionInCreation];
879 connector->removeFromScene();
880 unregisterController(connector);
881 _controllers.erase(_idConnectionInCreation);
883 std::map<int, GObjectController*>::iterator it;
884 for (it = _controllers.begin(); it != _controllers.end(); ++it) {
885 GObjectController *desc = it->second;
886 desc->SetActive(true);
887 desc->getView()->setState(NOTHING_HAPPENS);
888 desc->getModel()->notifyObservers(_idManager);
893 //=========================================================================
895 bool wxVtkSceneManager::OnRightButtonUp() {
896 if (_worldState == INIT_CREATION_CONTOUR) {
899 UnSelectBlackBoxes();
903 //=========================================================================
905 GObjectController *wxVtkSceneManager::GetGBlackBoxControlerPointedByMouse() {
906 GObjectController *result = NULL;
908 wxVTKRenderWindowInteractor *wxVTKiren;
910 = _vtkInteractorStyleBaseView->GetWxVtk3DBaseView()->GetWxVTKRenderWindowInteractor();
911 wxVTKiren->GetEventPosition(X, Y);
913 std::map<int, GObjectController*>::iterator it;
915 for (it = _controllers.begin(); it != _controllers.end(); ++it) {
916 GObjectController *cont = it->second;
917 int type = cont->getGObjectType();
919 if (cont->getView()->isPointInside(X, Y) == true) {
920 if (type == GBLACKBOX) {
923 } // if isPointInside
928 //=========================================================================
929 void wxVtkSceneManager::UnSelectBlackBoxes() {
930 for (int i = 0; i < (int) _selectedObjects.size(); i++) {
931 int id = _selectedObjects[i];
932 GObjectController* control = _controllers[id];
933 control->getView()->setState(NOTHING_HAPPENS);
934 }// for _selectedObjects
935 _selectedObjects.clear();
938 //=========================================================================
939 bool wxVtkSceneManager::OnLeftDClick() {
940 GObjectController *cont = GetGBlackBoxControlerPointedByMouse();
942 UnSelectBlackBoxes();
943 _parent->editBlackBox((GBlackBoxModel*) cont->getModel());
949 wxVTKRenderWindowInteractor *wxVTKiren;
950 wxVTKiren = _vtkInteractorStyleBaseView->GetWxVtk3DBaseView()->GetWxVTKRenderWindowInteractor();
951 wxVTKiren->GetEventPosition(X,Y);
953 std::map<int, GObjectController*>::iterator it;
955 bool clickOnObject = false;
957 for(it = _controllers.begin(); it != _controllers.end() && clickOnObject==false; ++it)
959 GObjectController *cont = it->second;
960 int type = cont->getGObjectType();
962 if(cont->getView()->isPointInside(X,Y))
966 for (int i=0; i< (int)_selectedObjects.size(); i++)
968 int id = _selectedObjects[i];
969 GObjectController* control = _controllers[id];
970 control->getView()->setState(NOTHING_HAPPENS);
972 _selectedObjects.clear();
974 GBlackBoxModel *bbmodel = (GBlackBoxModel*)cont->getModel();
975 _parent->editBlackBox(bbmodel);
977 clickOnObject = true;
981 if(clickOnObject==false)
983 //_parent->editDiagramParameters(this);
989 //=========================================================================
991 bool wxVtkSceneManager::OnChar() {
992 char keyCode = _vtkInteractorStyleBaseView->GetInteractor()-> GetKeyCode();
994 // KeyCode 127 : Delete Key
995 // KeyCode 8 : Backspace Key
996 if (keyCode == 8 || keyCode == 127) {
997 if (_selectedObjects.size() > 0) {
998 for (int i = 0; i < (int) _selectedObjects.size(); i++) {
999 int id = _selectedObjects[i];
1000 std::map<int, GObjectController*>::iterator it;
1001 it = _controllers.find(id);
1002 if (it != _controllers.end()) {
1006 _selectedObjects.clear();
1013 //=========================================================================
1015 void wxVtkSceneManager::AddControlerToBeRemove(
1016 std::vector<int> *controllersToRemove, int id) {
1020 for (i = 0; i < (int) controllersToRemove->size(); i++) {
1021 if (id == (*controllersToRemove)[i]) {
1027 controllersToRemove->push_back(id);
1032 //=========================================================================
1034 void wxVtkSceneManager::deleteObject(int id) {
1035 GObjectController *control = _controllers[id];
1036 std::vector<int> controllersToRemove;
1038 if (control->getGObjectType() == GBLACKBOX || control->getGObjectType()
1039 == GCOMPLEXINPUTPORT || control->getGObjectType()
1040 == GCOMPLEXOUTPUTPORT) {
1041 GBoxModel *bbmod = (GBoxModel*) control->getModel();
1042 std::vector<GPortModel*> inputs = bbmod->getInputPorts();
1044 bool boxConnected = false;
1046 // Add box input controllers to be removed
1047 for (int i = 0; i < (int) inputs.size(); i++) {
1048 AddControlerToBeRemove(&controllersToRemove,
1049 inputs[i]->getObjectId());
1050 if (inputs[i]->isConnected()) {
1051 boxConnected = true;
1055 std::vector<GPortModel*> outputs = bbmod->getOutputPorts();
1057 // Add box output controllers to be removed
1058 for (int i = 0; i < (int) outputs.size(); i++) {
1059 AddControlerToBeRemove(&controllersToRemove,
1060 outputs[i]->getObjectId());
1061 if (outputs[i]->isConnected()) {
1062 boxConnected = true;
1066 // Add connection controllers to be removed
1067 std::map<int, GObjectController*>::iterator it;
1068 for (it = _controllers.begin(); it != _controllers.end(); ++it) {
1069 GObjectController *cont = it->second;
1070 int type = cont->getGObjectType();
1071 if (type == GCONNECTOR) {
1072 GConnectorModel *conMod = (GConnectorModel*) cont->getModel();
1073 if (conMod->getStartPort() != NULL
1074 && conMod->getStartPort()->getParentBox()->getObjectId()
1075 == bbmod->getObjectId()) {
1076 AddControlerToBeRemove(&controllersToRemove,
1077 conMod->getObjectId());
1079 if (conMod->getEndPort() != NULL
1080 && conMod->getEndPort()->getParentBox()->getObjectId()
1081 == bbmod->getObjectId()) {
1082 AddControlerToBeRemove(&controllersToRemove,
1083 conMod->getObjectId());
1088 // Add box controller to be removed
1089 AddControlerToBeRemove(&controllersToRemove, bbmod->getObjectId());
1090 } else if (control->getGObjectType() == GCONNECTOR) {
1091 GConnectorModel *conMod = (GConnectorModel*) control->getModel();
1092 AddControlerToBeRemove(&controllersToRemove, conMod->getObjectId());
1095 std::map<int, GObjectController*>::iterator it;
1097 for (int i = 0; i < (int) controllersToRemove.size(); i++) {
1098 int key = controllersToRemove[i];
1099 it = _controllers.find(key);
1100 GObjectController *cont = _controllers[key];
1102 cont->removeFromScene();
1103 unregisterController((InteractorStyleMaracas*) cont);
1104 _controllers.erase(it);
1109 //=========================================================================
1111 void wxVtkSceneManager::displayBlackBoxInfo(std::string packageName,
1112 std::string boxName) {
1113 _parent->displayBlackBoxInfo(packageName, boxName);
1116 //=========================================================================
1118 void wxVtkSceneManager::updateStatusBar(std::string textStatus) {
1119 _parent->updateStatusBar(textStatus);
1122 //=========================================================================
1123 std::string wxVtkSceneManager::LineNumber(bool withLineNumber, int &value) {
1124 std::string result = "";
1125 if (withLineNumber == true) {
1127 stringstream StrStream;
1129 std::string strValue = StrStream.str();
1132 } else if (value < 100) {
1136 result += strValue + ": ";
1140 //=========================================================================
1142 bool wxVtkSceneManager::MakeBoxExecutable() {
1143 std::map<int, GObjectController*> selected = getSelectedObjects();
1144 if( selected.empty() )
1147 std::map<int, GObjectController*>::iterator it;
1148 for (it = selected.begin(); it != selected.end(); ++it) {
1149 GObjectController* lastSelected = it->second;
1151 vtkGObjectView* view = (vtkGObjectView*) lastSelected->getView();
1152 GBlackBoxModel *bbmodel =
1153 (GBlackBoxModel*) lastSelected->getModel();
1154 view->setState(HIGHLIGHTED);
1155 if (bbmodel->isExecutable()) {
1156 bbmodel->setExecutable(false);
1158 bbmodel->setExecutable(true);
1160 bbmodel->notifyObservers(lastSelected->getId());
1168 //=========================================================================
1170 std::string wxVtkSceneManager::getDiagramBBS(bool wln) {
1171 bool existsExec = false;
1173 std::vector<std::string> packages;
1174 std::vector<int> boxes;
1175 std::vector<int> connections;
1176 std::vector<int> execBoxes;
1178 std::map<int, GObjectController*>::iterator it;
1180 for (it = _controllers.begin(); it != _controllers.end(); ++it) {
1181 GObjectController *desc = it->second;
1182 int type = desc->getGObjectType();
1184 if (type == GBLACKBOX) {
1185 GBlackBoxModel *mod = (GBlackBoxModel*) desc->getModel();
1187 std::string pkg = mod->getBBTKPackage();
1188 bool existsPkg = false;
1189 for (int t = 0; t < (int) packages.size() && existsPkg == false; t++) {
1190 if (packages[t] == pkg) {
1195 packages.push_back(pkg);
1198 boxes.push_back(it->first);
1199 if (mod->isExecutable()) {
1200 execBoxes.push_back(it->first);
1203 } else if (type == GCONNECTOR) {
1204 connections.push_back(it->first);
1209 std::string script = "";
1210 script += LineNumber(wln, lnNmbr) + "# BBTK GEditor Script\n";
1211 script += LineNumber(wln, lnNmbr) + "# ----------------------\n";
1212 script += LineNumber(wln, lnNmbr) + "\n";
1214 script += LineNumber(wln, lnNmbr) + "include std\n"; // EED
1215 script += LineNumber(wln, lnNmbr) + "include itkvtk\n"; // EED
1217 for (i = 0; i < (int) packages.size(); i++) {
1218 script += LineNumber(wln, lnNmbr);
1219 script += "include ";
1220 script += packages[i];
1224 script += LineNumber(wln, lnNmbr);
1229 script += LineNumber(wln, lnNmbr);
1230 script += "author \"";
1234 script += LineNumber(wln, lnNmbr);
1235 script += "description \"";
1236 script += _Description;
1239 script += LineNumber(wln, lnNmbr);
1240 script += "category \"";
1241 script += _Category;
1244 script += LineNumber(wln, lnNmbr);
1247 // script+="include std\n"; // JPR
1249 for (i = 0; i < (int) boxes.size(); i++) {
1250 script += LineNumber(wln, lnNmbr);
1253 GObjectController *control = _controllers[id];
1254 GBlackBoxModel *model = (GBlackBoxModel*) control->getModel();
1256 script += model->getBBTKType();
1258 script += model->getBBTKName();
1261 std::vector<GPortModel*> inputs = model->getInputPorts();
1262 for (int j = 0; j < (int) inputs.size(); j++) {
1263 GPortModel* inputPort = inputs[j];
1264 if (inputPort->isValueSet()) {
1265 script += LineNumber(wln, lnNmbr);
1267 script += model->getBBTKName();
1269 script += inputPort->getBBTKName();
1271 script += inputPort->getValue();
1276 script += LineNumber(wln, lnNmbr);
1281 script += LineNumber(wln, lnNmbr);
1284 for (i = 0; i < (int) connections.size(); i++) {
1285 script += LineNumber(wln, lnNmbr);
1286 script += "connect ";
1287 int id = connections[i];
1288 GObjectController *control = _controllers[id];
1289 GConnectorModel *model = (GConnectorModel*) control->getModel();
1291 //Start Connection info
1292 GPortModel *start = model->getStartPort();
1293 script += start->getParentBox()->getBBTKName();
1295 script += start->getBBTKName();
1299 //End Connection info
1300 GPortModel *end = model->getEndPort();
1301 script += end->getParentBox()->getBBTKName();
1303 script += end->getBBTKName();
1308 script += LineNumber(wln, lnNmbr);
1310 for (i = 0; i < (int) execBoxes.size(); i++) {
1311 script += LineNumber(wln, lnNmbr);
1313 int id = execBoxes[i];
1314 GObjectController *control = _controllers[id];
1315 GBlackBoxModel *model = (GBlackBoxModel*) control->getModel();
1317 script += model->getBBTKName();
1326 //=========================================================================
1328 std::string wxVtkSceneManager::saveComplexBoxBBS() {
1329 std::vector<std::string> packages;
1330 std::vector<int> boxes;
1331 std::vector<int> connections;
1332 std::vector<int> execBoxes;
1334 std::map<int, GObjectController*>::iterator it;
1336 for (it = _controllers.begin(); it != _controllers.end(); ++it) {
1337 GObjectController *desc = it->second;
1338 int type = desc->getGObjectType();
1340 if (type == GBLACKBOX) {
1341 GBlackBoxModel *mod = (GBlackBoxModel*) desc->getModel();
1343 std::string pkg = mod->getBBTKPackage();
1344 bool existsPkg = false;
1345 for (int t = 0; t < (int) packages.size() && existsPkg == false; t++) {
1346 if (packages[t] == pkg) {
1351 packages.push_back(pkg);
1354 boxes.push_back(it->first);
1355 if (mod->isExecutable()) {
1356 execBoxes.push_back(it->first);
1358 } else if (type == GCONNECTOR) {
1359 connections.push_back(it->first);
1363 std::string script = "";
1365 script += "include std\n"; // EED
1366 script += "include itkvtk\n"; // EED
1368 for (i = 0; i < (int) packages.size(); i++) {
1369 script += "include ";
1370 script += packages[i];
1375 // Definition of a complex box
1376 script += "define ";
1377 script += _cbName + " " + _cbPackageName;
1381 script += "author \"";
1385 script += "description \"";
1386 script += _Description;
1390 script += "category \"";
1391 script += _Category;
1396 for (i = 0; i < (int) boxes.size(); i++) {
1399 GObjectController *control = _controllers[id];
1400 GBlackBoxModel *model = (GBlackBoxModel*) control->getModel();
1402 script += model->getBBTKType();
1404 script += model->getBBTKName();
1407 std::vector<GPortModel*> inputs = model->getInputPorts();
1408 for (int j = 0; j < (int) inputs.size(); j++) {
1409 GPortModel* inputPort = inputs[j];
1410 if (inputPort->isValueSet()) {
1412 script += model->getBBTKName();
1414 script += inputPort->getBBTKName();
1416 script += inputPort->getValue();
1424 // Create connections in the script. If the connection is made with a complex port, it is created the input or output
1426 std::string complexInputs = "";
1427 std::string complexOutputs = "";
1430 for (i = 0; i < (int) connections.size(); i++) {
1431 int id = connections[i];
1432 GObjectController *control = _controllers[id];
1433 GConnectorModel *model = (GConnectorModel*) control->getModel();
1436 GPortModel *start = model->getStartPort();
1437 GBoxModel *startBox = start->getParentBox();
1439 GPortModel *end = model->getEndPort();
1440 GBoxModel *endBox = end->getParentBox();
1442 if (startBox->getGObjectType() == GCOMPLEXINPUTPORT) {
1443 complexInputs += "input ";
1444 complexInputs += startBox->getBBTKName();
1446 complexInputs += " ";
1447 complexInputs += endBox->getBBTKName();
1448 complexInputs += ".";
1449 complexInputs += end->getBBTKName();
1451 complexInputs += " ";
1452 complexInputs += "\" \"";
1454 complexInputs += "\n";
1455 } else if (endBox->getGObjectType() == GCOMPLEXOUTPUTPORT) {
1456 complexOutputs += "output ";
1457 complexOutputs += endBox->getBBTKName();
1459 complexOutputs += " ";
1460 complexOutputs += startBox->getBBTKName();
1461 complexOutputs += ".";
1462 complexOutputs += start->getBBTKName();
1464 complexOutputs += " ";
1465 complexOutputs += "\" \"";
1467 complexOutputs += "\n";
1469 script += "connect ";
1470 script += startBox->getBBTKName();
1472 script += start->getBBTKName();
1476 //End Connection info
1477 script += endBox->getBBTKName();
1479 script += end->getBBTKName();
1487 for (i = 0; i < (int) execBoxes.size(); i++) {
1489 int id = execBoxes[i];
1490 GObjectController *control = _controllers[id];
1491 GBlackBoxModel *model = (GBlackBoxModel*) control->getModel();
1493 script += model->getBBTKName();
1498 script += "# Complex input ports\n";
1499 script += complexInputs;
1502 script += "# Complex output ports\n";
1503 script += complexOutputs;
1506 script += "endefine";
1512 //=========================================================================
1514 void wxVtkSceneManager::deleteAllBoxes() {
1515 std::map<int, GObjectController*>::iterator it;
1516 for (it = _controllers.begin(); it != _controllers.end(); ++it) {
1517 GObjectController *cont = it->second;
1518 cont->removeFromScene();
1519 unregisterController((InteractorStyleMaracas*) cont);
1521 _selectedObjects.clear();
1522 _controllers.clear();
1526 //=========================================================================
1529 void wxVtkSceneManager::refresh() {
1530 _baseView->Refresh();
1532 //=========================================================================
1534 void wxVtkSceneManager::refreshScene() {
1535 _baseView->RefreshView();
1538 //=========================================================================
1540 void wxVtkSceneManager::centerView() {
1542 _baseView->GetRenderer()->GetActiveCamera()->GetFocalPoint(temp);
1543 _baseView->GetRenderer()->GetActiveCamera()->SetFocalPoint(0, 0, temp[2]);
1544 _baseView->GetRenderer()->GetActiveCamera()->GetPosition(temp);
1545 _baseView->GetRenderer()->GetActiveCamera()->SetPosition(0, 0, temp[2]);
1546 _baseView->RefreshView();
1550 //=========================================================================
1552 void wxVtkSceneManager::saveDiagram(std::string &content) {
1555 content += "CATEGORY:";
1556 content += GetCategory();
1559 content += "DESCRIPTION:";
1560 content += GetDescription();
1563 content += "AUTHOR:";
1564 content += GetAuthor();
1567 //Print info IF COMPLEX BOX
1568 content += "COMPLEXBOX:";
1569 if (_isComplexBox) {
1570 content += "TRUE\n";
1572 content += "COMPLEXBOXNAME:";
1573 content += GetCbName();
1576 content += "PACKAGENAME:";
1577 content += GetCbPackageName();
1580 //Print info complex input ports
1581 std::vector<int> inputs = getComplexInputPorts();
1582 int insize = inputs.size();
1583 content += "COMPLEXINPUTS:";
1584 sprintf(buffer, "%d", insize);
1588 for (int i = 0; i < insize; i++) {
1590 GObjectController *cont = _controllers[id];
1591 cont->getModel()->save(content);
1594 //Print info complex output ports
1595 std::vector<int> outputs = getComplexOutputPorts();
1596 int outsize = outputs.size();
1597 content += "COMPLEXOUTPUTS:";
1598 sprintf(buffer, "%d", outsize);
1602 for (int i = 0; i < outsize; i++) {
1603 int id = outputs[i];
1604 GObjectController *cont = _controllers[id];
1605 cont->getModel()->save(content);
1609 content += "FALSE\n";
1613 std::vector<int> boxes = getBlackBoxes();
1614 int bsize = boxes.size();
1615 content += "BOXES:";
1616 sprintf(buffer, "%d", bsize);
1620 for (int i = 0; i < bsize; i++) {
1622 GObjectController *cont = _controllers[id];
1623 cont->getModel()->save(content);
1627 std::vector<int> connections = getConnections();
1628 int csize = connections.size();
1629 content += "CONNECTIONS:";
1630 sprintf(buffer, "%d", csize);
1634 for (int i = 0; i < csize; i++) {
1635 int id = connections[i];
1636 GObjectController *cont = _controllers[id];
1637 cont->getModel()->save(content);
1642 //=========================================================================
1644 void wxVtkSceneManager::loadDiagram(ifstream &inputStream) {
1646 std::string version = "<void>";
1647 std::string line = "";
1648 char delims[] = ":";
1649 char *result = NULL;
1650 getline(inputStream, line);
1653 while (!inputStream.eof()) {
1654 if (line == "" || line[0] == '#') {
1655 getline(inputStream, line);
1656 if (line == "# - BBTKGEditor v 1.0 BBG BlackBox Diagram file") {
1657 version = line.substr(18, 3);
1659 if (line == "# - BBTKGEditor v 1.1 BBG BlackBox Diagram file") {
1660 version = line.substr(18, 3);
1662 if (line == "# - BBTKGEditor v 1.2 BBG BlackBox Diagram file") {
1663 version = line.substr(18, 3);
1665 } else if (line == "APP_START") {
1671 printf("EED wxVtkSceneManager::loadDiagram version=%s\n", version.c_str());
1675 if ((version != "1.0") && (version != "1.1")) {
1676 getline(inputStream, line);//CATEGORY:<category of the box>
1677 char categoryTmp[30];
1678 strcpy(categoryTmp, line.c_str());
1679 result = strtok(categoryTmp, delims);
1680 result = strtok(NULL, delims);
1681 SetCategory(result);
1683 getline(inputStream, line);//DESCRIPTION:<description of the box>
1684 char descriptionTmp[1024];
1685 strcpy(descriptionTmp, line.c_str());
1686 result = strtok(descriptionTmp, delims);
1687 result = strtok(NULL, delims);
1688 SetDescription(result);
1690 getline(inputStream, line);//AUTHOR:<author>
1691 char authorTmp[255];
1692 strcpy(authorTmp, line.c_str());
1693 result = strtok(authorTmp, delims);
1694 result = strtok(NULL, delims);
1699 getline(inputStream, line);//COMPLEX_BOX:TRUE|FALSE
1700 char complexTmp[30];
1701 strcpy(complexTmp, line.c_str());
1702 result = strtok(complexTmp, delims);
1703 result = strtok(NULL, delims);
1704 std::string isComplexBox(result);
1706 if (isComplexBox == "TRUE") {
1707 _isComplexBox = true;
1709 if ((version != "1.0") && (version != "1.1")) {
1710 getline(inputStream, line);//COMPLEXNAME:<name of the complex box>
1711 char complexboxnameTmp[255];
1712 strcpy(complexboxnameTmp, line.c_str());
1713 result = strtok(complexboxnameTmp, delims);
1714 result = strtok(NULL, delims);
1717 getline(inputStream, line);//PACKAGENAME:<name of the package of the box>
1718 char packagenameTmp[255];
1719 strcpy(packagenameTmp, line.c_str());
1720 result = strtok(packagenameTmp, delims);
1721 result = strtok(NULL, delims);
1722 SetCbPackageName(result);
1725 //-----------------------
1726 //- COMPLEX INPUT PORTS
1727 //-----------------------
1728 getline(inputStream, line);//COMPLEXINPUTS:num
1730 strcpy(inputs, line.c_str());
1731 result = strtok(inputs, delims);
1732 result = strtok(NULL, delims);
1735 std::istringstream inps(result);
1738 for (int i = 0; i < numInputs; i++) {
1740 getline(inputStream, line);//COMPLEX_PORT
1741 getline(inputStream, line);//name
1742 std::string inputPortName(line);
1745 getline(inputStream, line);//xInic:yInic:zInic
1747 strcpy(coord, line.c_str());
1748 result = strtok(coord, delims);//xInic
1749 std::string xInic(result);
1750 result = strtok(NULL, delims);//yInic
1751 std::string yInic(result);
1752 result = strtok(NULL, delims);//zInic
1753 std::string zInic(result);
1755 double xIn, yIn, zIn;
1756 std::istringstream xSt(xInic);
1758 std::istringstream ySt(yInic);
1760 std::istringstream zSt(zInic);
1763 getline(inputStream, line);//FIN_COMPLEX_PORT
1765 configGComBoxInputOutputPort(true, inputPortName, xIn, yIn, zIn);
1767 } // for input complex box
1770 //-----------------------
1771 //- COMPLEX OUTPUT PORTS
1772 //-----------------------
1774 getline(inputStream, line);//COMPLEXOUTPUTS:num
1776 strcpy(outputs, line.c_str());
1777 result = strtok(outputs, delims);
1778 result = strtok(NULL, delims);
1781 std::istringstream outps(result);
1782 outps >> numOutputs;
1784 for (int i = 0; i < numOutputs; i++) {
1786 getline(inputStream, line);//COMPLEX_PORT
1787 getline(inputStream, line);//name
1788 std::string outputPortName(line);
1791 getline(inputStream, line);//xInic:yInic:zInic
1793 strcpy(coord, line.c_str());
1794 result = strtok(coord, delims);//xInic
1795 std::string xInic(result);
1796 result = strtok(NULL, delims);//yInic
1797 std::string yInic(result);
1798 result = strtok(NULL, delims);//zInic
1799 std::string zInic(result);
1801 double xIn, yIn, zIn;
1802 std::istringstream xSt(xInic);
1804 std::istringstream ySt(yInic);
1806 std::istringstream zSt(zInic);
1809 getline(inputStream, line);//FIN_COMPLEX_PORT
1811 configGComBoxInputOutputPort(false, outputPortName, xIn, yIn,
1814 } // for output complex box
1819 getline(inputStream, line);//BOXES:num
1821 strcpy(boxes, line.c_str());
1822 result = strtok(boxes, delims);
1823 result = strtok(NULL, delims);
1826 std::istringstream is(result);
1829 for (int i = 0; i < numBoxes; i++) {
1831 getline(inputStream, line);//BOX
1832 getline(inputStream, line);//package:type:name
1834 strcpy(box, line.c_str());
1835 result = strtok(box, delims);//package
1836 std::string package(result);
1837 result = strtok(NULL, delims);//type
1838 std::string type(result);
1839 result = strtok(NULL, delims);//name
1840 std::string name(result);
1842 getline(inputStream, line);//ISEXEC:TRUE|FALSE
1844 strcpy(exec, line.c_str());
1845 result = strtok(exec, delims);//ISEXEC
1846 result = strtok(NULL, delims);//TRUE|FALSE
1847 std::string isExec(result);
1850 getline(inputStream, line);//xInic:yInic:zInic
1852 strcpy(coord, line.c_str());
1853 result = strtok(coord, delims);//xInic
1854 std::string xInic(result);
1855 result = strtok(NULL, delims);//yInic
1856 std::string yInic(result);
1857 result = strtok(NULL, delims);//zInic
1858 std::string zInic(result);
1860 double xIn, yIn, zIn;
1861 std::istringstream xSt(xInic);
1863 std::istringstream ySt(yInic);
1865 std::istringstream zSt(zInic);
1869 getline(inputStream, line);//xEnd:yEnd:zEnd
1870 strcpy(coord, line.c_str());
1871 result = strtok(coord, delims);//xEnd
1872 std::string xEnd(result);
1873 result = strtok(NULL, delims);//yEnd
1874 std::string yEnd(result);
1875 result = strtok(NULL, delims);//zEnd
1876 std::string zEnd(result);
1878 double xEn, yEn, zEn;
1879 std::istringstream xEt(xEnd);
1881 std::istringstream yEt(yEnd);
1883 std::istringstream zEt(zEnd);
1886 bool boxExecutable = false;
1887 if (isExec == "TRUE") {
1888 boxExecutable = true;
1891 int idBox = createGBlackBox(xIn, yIn, package, type);
1892 configGBlackBox(idBox, xIn, yIn, zIn, name, boxExecutable, xEn,
1895 GObjectController *cont = _controllers[idBox];
1896 GBlackBoxModel *bbmod = (GBlackBoxModel*) cont->getModel();
1899 getline(inputStream, line);//PORT o FIN_BOX
1900 std::string port = line.substr(0, 4);
1901 while (port == "PORT") {
1902 getline(inputStream, line);//name:value
1904 strcpy(poort, line.c_str());
1905 result = strtok(poort, delims);//name
1906 std::string name(result);
1907 result = strtok(NULL, delims);//value
1908 std::string value(result);
1910 bbmod->setValueToInput(name, value);
1912 getline(inputStream, line);//PORT o FIN_BOX
1913 port = line.substr(0, 4);
1916 //EED bbmod->notifyObservers(_idManager);
1921 getline(inputStream, line);//CONNECTIONS:num
1923 strcpy(conns, line.c_str());
1924 result = strtok(conns, delims);
1925 result = strtok(NULL, delims);
1928 std::istringstream isCons(result);
1931 for (int i = 0; i < numConns; i++) {
1933 getline(inputStream, line);//CONNECTION
1934 getline(inputStream, line);//Startbox.PortName:EndBox.PortName
1937 strcpy(connec, line.c_str());
1938 result = strtok(connec, delims);
1939 std::string nameStartBox(result);
1940 result = strtok(NULL, delims);
1941 std::string nameStartPort(result);
1942 result = strtok(NULL, delims);
1943 std::string nameEndBox(result);
1944 result = strtok(NULL, delims);
1945 std::string nameEndPort(result);
1947 int idCon = configGConnetion(nameStartBox, nameStartPort,
1948 nameEndBox, nameEndPort);
1950 if (version != "1.0") {
1951 //Readding control points of the manualContour
1953 GConnectorController *tempp =
1954 (GConnectorController*) _controllers[idCon];
1955 GConnectorModel *conMod = (GConnectorModel*) tempp->getModel();
1956 vtkGConnectorView *conView =
1957 (vtkGConnectorView*) tempp->getView();
1958 getline(inputStream, line); //NumberOfControlPoints:##
1959 strcpy(conns, line.c_str());
1960 result = strtok(conns, delims);
1961 result = strtok(NULL, delims);
1963 int numberOfControlPoints;
1964 std::istringstream isCons(result);
1965 isCons >> numberOfControlPoints;
1967 for (int ii = 0; ii < numberOfControlPoints; ii++) {
1968 getline(inputStream, line); //XX:YY:ZZ
1970 strcpy(connec, line.c_str());
1973 result = strtok(connec, delims);
1974 std::istringstream isPointX(result);
1976 result = strtok(NULL, delims);
1977 std::istringstream isPointY(result);
1979 result = strtok(NULL, delims);
1980 std::istringstream isPointZ(result);
1983 conMod->getManualContourModel()->InsertPoint_id(ii + 1, px,
1985 conView->getManualContourView()->AddPoint();
1995 //=========================================================================
1998 //=========================================================================
1999 void wxVtkSceneManager::configGComBoxInputOutputPort(bool inputoutput,
2000 std::string portName, double xIn, double yIn, double zIn) {
2002 if (inputoutput == true) {
2003 idPort = createGComplexBoxInputPort(portName);
2005 idPort = createGComplexBoxOutputPort(portName);
2007 GObjectController *cont = _controllers[idPort];
2008 GBoxModel *cbmod = (GBoxModel*) cont->getModel();
2009 cbmod->setInicPoint(xIn, yIn, zIn);
2010 cbmod->notifyObservers(_idManager);
2012 //=========================================================================
2015 //=========================================================================
2016 GBoxModel* wxVtkSceneManager::findGBox(std::string boxname) {
2020 GBoxModel *boxModel = NULL;
2021 std::vector<int> lstB = getBlackBoxes();
2022 for (j = 0; j < (int) lstB.size(); j++) {
2024 bMod = (GBoxModel*) _controllers[idB]->getModel();
2025 if (_controllers[idB]->getModel()->getBBTKName() == boxname) {
2030 if ((_isComplexBox) && (boxModel == NULL)) {
2031 std::vector<int> lstInputs = getComplexInputPorts();
2032 for (j = 0; j < (int) lstInputs.size(); j++) {
2034 bMod = (GBoxModel*) _controllers[idB]->getModel();
2035 if (_controllers[idB]->getModel()->getBBTKName() == boxname) {
2040 std::vector<int> lstOutputs = getComplexOutputPorts();
2041 for (j = 0; j < (int) lstOutputs.size(); j++) {
2042 int idB = lstOutputs[j];
2043 bMod = (GBoxModel*) _controllers[idB]->getModel();
2044 if (_controllers[idB]->getModel()->getBBTKName() == boxname) {
2054 //=========================================================================
2057 int wxVtkSceneManager::configGConnetion(std::string nameStartBox,
2058 std::string nameStartPort, std::string nameEndBox,
2059 std::string nameEndPort) {
2061 GBoxModel *boxModel;
2062 GPortModel *startP = NULL;
2063 GPortModel *endP = NULL;
2065 boxModel = findGBox(nameStartBox);
2066 if (boxModel != NULL) {
2067 startP = boxModel->getOutputPort(nameStartPort);
2070 boxModel = findGBox(nameEndBox);
2071 if (boxModel != NULL) {
2072 endP = boxModel->getInputPort(nameEndPort);
2076 int idCon = createGConnector(startP);
2077 _worldState = NOTHING_HAPPENS;
2078 GConnectorController *tempp = (GConnectorController*) _controllers[idCon];
2080 GConnectorModel *conMod = (GConnectorModel*) tempp->getModel();
2081 vtkGConnectorView *conView = (vtkGConnectorView*) tempp->getView();
2082 tempp->endContourCreation();
2083 conMod->setEndPort(endP);
2084 conView->updateStartEndPoints();
2088 //=========================================================================
2090 bool wxVtkSceneManager::boxExist(std::string boxname) {
2092 std::map<int, GObjectController*>::iterator it;
2093 for (it = _controllers.begin(); it != _controllers.end(); ++it) {
2094 GObjectController *cont = it->second;
2095 if (cont->getModel()->getBBTKName() == boxname) {
2102 //=========================================================================
2104 std::vector<int> wxVtkSceneManager::getBlackBoxes() {
2105 std::vector<int> vect;
2106 std::map<int, GObjectController*>::iterator it;
2107 for (it = _controllers.begin(); it != _controllers.end(); ++it) {
2108 GObjectController *cont = it->second;
2109 if (cont->getGObjectType() == GBLACKBOX) {
2110 vect.push_back(cont->getId());
2116 //=========================================================================
2118 std::vector<int> wxVtkSceneManager::getComplexInputPorts() {
2119 std::vector<int> vect;
2120 std::map<int, GObjectController*>::iterator it;
2121 for (it = _controllers.begin(); it != _controllers.end(); ++it) {
2122 GObjectController *cont = it->second;
2123 if (cont->getGObjectType() == GCOMPLEXINPUTPORT) {
2124 vect.push_back(cont->getId());
2130 //=========================================================================
2132 std::vector<int> wxVtkSceneManager::getComplexOutputPorts() {
2133 std::vector<int> vect;
2134 std::map<int, GObjectController*>::iterator it;
2135 for (it = _controllers.begin(); it != _controllers.end(); ++it) {
2136 GObjectController *cont = it->second;
2137 if (cont->getGObjectType() == GCOMPLEXOUTPUTPORT) {
2138 vect.push_back(cont->getId());
2144 //=========================================================================
2146 std::vector<int> wxVtkSceneManager::getConnections() {
2147 std::vector<int> vect;
2148 std::map<int, GObjectController*>::iterator it;
2149 for (it = _controllers.begin(); it != _controllers.end(); ++it) {
2150 GObjectController *cont = it->second;
2151 if (cont->getGObjectType() == GCONNECTOR) {
2152 vect.push_back(cont->getId());
2158 //=========================================================================
2160 bool wxVtkSceneManager::isComplexBox() {
2161 return _isComplexBox;
2164 //=========================================================================
2166 void wxVtkSceneManager::setComplexBox(bool val) {
2167 _isComplexBox = val;
2170 //=========================================================================
2172 int wxVtkSceneManager::addObjectController(GObjectController* objController) {
2173 //Register the controller of the new object
2174 registerController((InteractorStyleMaracas*) objController);
2175 //Add the object to the objects list
2176 int newId = _contLastId;//_controllers.size();
2177 objController->setId(newId);
2178 _controllers[newId] = objController;
2180 << "DFCH: int wxVtkSceneManager::addObjectController(GObjectController* objController) ---- _contLastId = "
2181 << _contLastId << std::endl;
2186 //=========================================================================
2188 int wxVtkSceneManager::getNumSelectedObjects() {
2189 return _selectedObjects.size();
2192 //=========================================================================
2194 std::map<int, GObjectController*> wxVtkSceneManager::getSelectedObjects() {
2195 std::map<int, GObjectController*> mapSelected;
2197 std::map<int, GObjectController*>::iterator it;
2198 for (it = _controllers.begin(); it != _controllers.end(); ++it) {
2199 GObjectController *cont = it->second;
2200 if (cont->getGObjectType() == GBLACKBOX && cont->getView()->getState()
2202 mapSelected[cont->getId()] = cont;
2206 std::map<int, GObjectController*>::iterator it2;
2207 for (it2 = _controllers.begin(); it2 != _controllers.end(); ++it2) {
2208 GObjectController *cont = it2->second;
2209 if (cont->getGObjectType() == GCONNECTOR) {
2210 GConnectorModel* cmod = (GConnectorModel*) cont->getModel();
2211 GBoxModel* endPortParentBox = cmod->getEndPort()->getParentBox();
2212 GBoxModel* startPortParentBox =
2213 cmod->getStartPort()->getParentBox();
2215 std::map<int, GObjectController*>::iterator iterOBJ1 =
2216 mapSelected.find(startPortParentBox->getObjectId());
2217 std::map<int, GObjectController*>::iterator iterOBJ2 =
2218 mapSelected.find(endPortParentBox->getObjectId());
2220 if (iterOBJ1 != mapSelected.end() && iterOBJ2 != mapSelected.end()) {
2221 int ID = cont->getId();
2222 mapSelected[ID] = cont;
2229 //=========================================================================
2231 void wxVtkSceneManager::addObjects(std::map<int, GObjectController*> objectsMap) {
2233 std::map<int, int> oldIdNewIdBoxes;
2234 std::vector<int> connections;
2236 std::map<int, GObjectController*>::iterator it;
2237 for (it = objectsMap.begin(); it != objectsMap.end(); ++it) {
2238 GObjectController *cont = it->second;
2239 int type = cont->getGObjectType();
2241 if (type == GBLACKBOX) {
2243 double xInic, yInic, zInic;
2244 GBlackBoxModel* copyBox = (GBlackBoxModel*) cont->getModel();
2245 copyBox->getInicPoint(xInic, yInic, zInic);
2246 int idBox = createGBlackBox(0, 0, copyBox->getBBTKPackage(),
2247 copyBox->getBBTKType());
2249 int idcB = copyBox->getObjectId();
2250 oldIdNewIdBoxes[idcB] = idBox;
2251 cont = _controllers[idBox];
2252 GBlackBoxModel* newbox = (GBlackBoxModel*) cont->getModel();
2253 newbox->setInicPoint(xInic, yInic, zInic);
2254 int num = newbox->getNumInputPorts();
2255 for (int j = 0; j < num; j++) {
2256 newbox->setValueToInputPort(j, copyBox->getValueInputPort(j));
2258 newbox->notifyObservers(_idManager);
2259 } else if (type == GCONNECTOR) {
2260 int idCon = cont->getId();
2261 connections.push_back(idCon);
2266 for (int i = 0; i < (int) connections.size(); i++) {
2267 int objId = connections[i];
2268 GObjectController *cont = objectsMap[objId];
2269 GConnectorModel* connectModel = (GConnectorModel*) cont->getModel();
2271 GPortModel* startPort = connectModel->getStartPort();
2272 int startPortIndex = startPort->getPosInBox();
2273 GPortModel* endPort = connectModel->getEndPort();
2274 int endPortIndex = endPort->getPosInBox();
2276 GBlackBoxModel* startPortParentBox =
2277 (GBlackBoxModel*) startPort->getParentBox();
2278 GBlackBoxModel* endPortParentBox =
2279 (GBlackBoxModel*) endPort->getParentBox();
2281 int idNewStartBox = oldIdNewIdBoxes[startPortParentBox->getObjectId()];
2282 int idNewEndBox = oldIdNewIdBoxes[endPortParentBox->getObjectId()];
2284 GBlackBoxModel* newStartBox =
2285 (GBlackBoxModel*) _controllers[idNewStartBox]->getModel();
2286 GBlackBoxModel* newEndBox =
2287 (GBlackBoxModel*) _controllers[idNewEndBox]->getModel();
2289 GPortModel* newStartPort = newStartBox->getOutputPort(startPortIndex);
2290 GPortModel* newEndPort = newEndBox->getInputPort(endPortIndex);
2292 // Creates connection
2293 int idCon = createGConnector(newStartPort);
2294 GConnectorController *tempp =
2295 (GConnectorController*) _controllers[idCon];
2296 GConnectorModel *conMod = (GConnectorModel*) tempp->getModel();
2297 vtkGConnectorView *conView = (vtkGConnectorView*) tempp->getView();
2298 tempp->endContourCreation();
2299 conMod->setEndPort(newEndPort);
2300 conView->updateStartEndPoints();
2303 std::map<int, int>::iterator itIds;
2304 for (itIds = oldIdNewIdBoxes.begin(); itIds != oldIdNewIdBoxes.end(); ++itIds) {
2305 int idOld = itIds->first;
2306 int idNew = itIds->second;
2308 GBlackBoxModel* oldBox =
2309 (GBlackBoxModel*) objectsMap[idOld]->getModel();
2310 GBlackBoxModel* newBox =
2311 (GBlackBoxModel*) _controllers[idNew]->getModel();
2313 std::vector<int> oldInputConnections = oldBox->getConnectedInputs();
2314 std::vector<int> oldOutputConnections = oldBox->getConnectedOutputs();
2315 std::vector<int> newInputConnections = newBox->getConnectedInputs();
2316 std::vector<int> newOutputConnections = newBox->getConnectedOutputs();
2318 for (int k = 0; k < (int) oldInputConnections.size(); k++) {
2320 //EED int toCreate=-1;
2321 for (int l = 0; l < (int) newInputConnections.size() && !exist; l++) {
2322 if (oldInputConnections[k] == newInputConnections[l]) {
2327 if (exist == false) {
2328 //Create complex input
2329 int posInBox = oldInputConnections[k];
2330 GPortModel* inputPort = oldBox->getInputPort(posInBox);
2331 std::string inputPortName = inputPort->getBBTKName();
2332 int idInputPort = createGComplexBoxInputPort(inputPortName);
2333 GObjectController *cont = _controllers[idInputPort];
2334 GBoxModel *cbmod = (GBoxModel*) cont->getModel();
2335 double xIn, yIn, zIn;
2336 inputPort->getInicPoint(xIn, yIn, zIn);
2338 cbmod->setInicPoint(xIn, yIn, zIn);
2339 cbmod->notifyObservers(_idManager);
2341 GPortModel* inputPortEnd = newBox->getInputPort(posInBox);
2343 // Creates connection
2344 int idCon = createGConnector(cbmod->getOutputPort(0));
2345 GConnectorController *tempp =
2346 (GConnectorController*) _controllers[idCon];
2347 GConnectorModel *conMod = (GConnectorModel*) tempp->getModel();
2348 vtkGConnectorView *conView =
2349 (vtkGConnectorView*) tempp->getView();
2350 tempp->endContourCreation();
2351 conMod->setEndPort(inputPortEnd);
2352 conView->updateStartEndPoints();
2358 for (int k = 0; k < (int) oldOutputConnections.size(); k++) {
2360 //EED int toCreate=-1;
2361 for (int l = 0; l < (int) newOutputConnections.size() && !exist; l++) {
2362 if (oldOutputConnections[k] == newOutputConnections[l]) {
2367 if (exist == false) {
2368 //Create complex output
2369 int posInBox = oldOutputConnections[k];
2370 GPortModel* outputPort = oldBox->getOutputPort(posInBox);
2371 std::string outputPortName = outputPort->getBBTKName();
2372 int idOutputPort = createGComplexBoxOutputPort(outputPortName);
2373 GObjectController *cont = _controllers[idOutputPort];
2374 GBoxModel *cbmod = (GBoxModel*) cont->getModel();
2375 double xIn, yIn, zIn;
2376 outputPort->getInicPoint(xIn, yIn, zIn);
2378 cbmod->setInicPoint(xIn, yIn, zIn);
2379 cbmod->notifyObservers(_idManager);
2381 GPortModel* outputPortEnd = newBox->getOutputPort(posInBox);
2383 // Creates connection
2384 int idCon = createGConnector(outputPortEnd);
2385 GConnectorController *tempp =
2386 (GConnectorController*) _controllers[idCon];
2387 GConnectorModel *conMod = (GConnectorModel*) tempp->getModel();
2388 vtkGConnectorView *conView =
2389 (vtkGConnectorView*) tempp->getView();
2390 tempp->endContourCreation();
2391 conMod->setEndPort(cbmod->getInputPort(0));
2392 conView->updateStartEndPoints();
2402 //=========================================================================
2403 void wxVtkSceneManager::SetCbName(std::string cbName) {
2405 if (_cbName == "") {
2406 _cbName = "<complex box name>";
2410 //=========================================================================
2411 std::string wxVtkSceneManager::GetCbName() {
2415 //=========================================================================
2416 void wxVtkSceneManager::SetCbPackageName(std::string packagename) {
2417 _cbPackageName = packagename;
2418 if (_cbPackageName == "") {
2419 _cbPackageName = "<package name of the complex box>";
2423 //=========================================================================
2424 std::string wxVtkSceneManager::GetCbPackageName() {
2425 return _cbPackageName;
2428 //=========================================================================
2429 void wxVtkSceneManager::SetAuthor(std::string author) {
2431 if (_Author == "") {
2432 _Author = "<author of the box>";
2436 //=========================================================================
2437 std::string wxVtkSceneManager::GetAuthor() {
2441 //=========================================================================
2442 void wxVtkSceneManager::SetCategory(std::string category) {
2443 _Category = category;
2444 if (_Category == "") {
2445 _Category = "<category of the box>";
2449 //=========================================================================
2450 std::string wxVtkSceneManager::GetCategory() {
2454 //=========================================================================
2455 void wxVtkSceneManager::SetDescription(std::string description) {
2456 _Description = description;
2457 if (_Description == "") {
2458 _Description = "<description of the box>";
2462 //=========================================================================
2463 std::string wxVtkSceneManager::GetDescription() {
2464 return _Description;
2467 //=========================================================================
2470 } // EO namespace bbtk