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);
688 _parent->saveTempDiagram();
691 manualConnectorContourController
693 ((GConnectorController*) cont)->getManualContourController();
694 manualConnectorContourView
696 (manualConnectorContourView*) manCont->GetManualViewBaseContour();
699 std::map<int, GObjectController*>::iterator it2;
701 for (it2 = _controllers.begin(); it2 != _controllers.end(); ++it2) {
702 GObjectController *cont = it2->second;
703 if (cont->getView() != NULL) {
704 cont->getView()->setState(NOTHING_HAPPENS);
705 cont->getModel()->notifyObservers(_idManager);
707 cont->SetActive(true);
715 //=========================================================================
717 bool wxVtkSceneManager::OnMouseMove() {
719 bool okStatusMessage = false;
720 bool okPortMessage = false;
721 wxVTKRenderWindowInteractor *wxVTKiren;
723 = _vtkInteractorStyleBaseView->GetWxVtk3DBaseView()->GetWxVTKRenderWindowInteractor();
724 wxVTKiren->GetEventPosition(X, Y);
726 if (_worldState == DRAG_OBJECTS) {
727 for (int i = 0; i < (int) _selectedObjects.size(); i++) {
728 int id = _selectedObjects[i];
729 GObjectController* cont = _controllers[id];
730 if (_startDragging) {
731 cont->getView()->setStartDragging(true);
733 cont->getView()->moveObject(X, Y);
734 cont->getView()->setState(DRAG);
735 cont->getModel()->notifyObservers(_idManager);
738 std::map<int, GObjectController*>::iterator it;
740 for (it = _controllers.begin(); it != _controllers.end(); ++it) {
741 GObjectController *desc = it->second;
742 if (desc->getGObjectType() == GCONNECTOR) {
743 vtkGConnectorView* vconn = (vtkGConnectorView*) desc->getView();
744 vconn->updateStartEndPoints();
748 _startDragging = false;
750 } else if (_worldState == NOTHING_HAPPENS || _worldState
751 == INIT_CREATION_CONTOUR) {
752 std::map<int, GObjectController*>::iterator it;
754 for (it = _controllers.begin(); it != _controllers.end(); ++it) {
755 GObjectController *desc = it->second;
756 int type = desc->getGObjectType();
757 int state = desc->getView()->getState();
758 desc->getModel()->getCenter(px, py, pz);
760 if (state == HIGHLIGHTED) {
761 okStatusMessage = true;
762 updateStatusBar(desc->getStatusText());
763 if (type == GBLACKBOX) {
764 GBlackBoxModel *mod = (GBlackBoxModel*) desc->getModel();
765 _parent->displayBlackBoxInfo(mod->getBBTKPackage(),
770 okPortMessage = true;
772 _textActor->SetInput(desc->getStatusText().c_str());
773 _textActor->SetScale(0.1);
774 _textActor->SetPosition(px - 25, py + 1, pz + 2);
779 _fillObjectActor->SetScale(1);
780 _fillObjectActor->GetProperty()->SetOpacity(0.50);
781 _fillObjectActor->SetPosition(px, py, 1);
782 _aPolygonMapper->Modified();
785 } // for controllers it
788 if (okStatusMessage == false) {
792 if (okPortMessage == false) {
793 _textActor->SetScale(0.0001);
794 _fillObjectActor->SetScale(0.0001);
799 //=========================================================================
801 bool wxVtkSceneManager::OnLeftButtonDown() {
803 if (_worldState == INIT_CREATION_CONTOUR) {
804 bool isOverPort = false;
805 std::map<int, GObjectController*>::iterator it;
806 for (it = _controllers.begin(); it != _controllers.end() && isOverPort
808 GObjectController *desc = it->second;
809 if (desc->getGObjectType() == GPORT) {
810 GPortModel *portmod = (GPortModel*) desc->getModel();
811 vtkGObjectView *portView = desc->getView();
812 if (portmod->getPortType() == GINPUTPORT
813 && portView->getState() == HIGHLIGHTED) {
819 if (isOverPort == false) {
821 UnSelectBlackBoxes();
825 } else { //_worldState
827 _worldState = DRAG_OBJECTS;
828 _startDragging = true;
831 _vtkInteractorStyleBaseView->GetInteractor()->GetShiftKey();
833 _vtkInteractorStyleBaseView->GetInteractor()->GetControlKey();
834 ctrlkey = ctrlkey + shiftkey;
836 GObjectController *cont = GetGBlackBoxControlerPointedByMouse();
838 if (GetGBlackBoxControlerPointedByMouse() != NULL) {
839 int state = cont->getView()->getState();
840 if ((ctrlkey == 0) && (state == HIGHLIGHTED)) {
841 UnSelectBlackBoxes();
844 for (int i = 0; i < (int) _selectedObjects.size(); i++) {
845 int id = _selectedObjects[i];
846 GObjectController* cont = _controllers[id];
847 cont->getView()->setState(DRAG);
848 cont->getModel()->notifyObservers(_idManager);
851 } // if _selectedObjects.size
857 //=========================================================================
859 bool wxVtkSceneManager::OnLeftButtonUp() {
860 if (_worldState == DRAG_OBJECTS) {
861 _worldState = NOTHING_HAPPENS;
863 for (int i = 0; i < (int) _selectedObjects.size(); i++) {
864 int id = _selectedObjects[i];
865 GObjectController* cont = _controllers[id];
866 cont->getView()->setState(SELECTED);
867 cont->getModel()->notifyObservers(_idManager);
873 //=========================================================================
874 void wxVtkSceneManager::CancelConnection() {
875 if (_worldState == INIT_CREATION_CONTOUR) {
876 _worldState = NOTHING_HAPPENS;
877 //int lastId = _controllers.size()-1;
879 GConnectorController *connector =
880 (GConnectorController*) _controllers[_idConnectionInCreation];
881 connector->removeFromScene();
882 unregisterController(connector);
883 _controllers.erase(_idConnectionInCreation);
885 std::map<int, GObjectController*>::iterator it;
886 for (it = _controllers.begin(); it != _controllers.end(); ++it) {
887 GObjectController *desc = it->second;
888 desc->SetActive(true);
889 desc->getView()->setState(NOTHING_HAPPENS);
890 desc->getModel()->notifyObservers(_idManager);
895 //=========================================================================
897 bool wxVtkSceneManager::OnRightButtonUp() {
898 if (_worldState == INIT_CREATION_CONTOUR) {
901 UnSelectBlackBoxes();
905 //=========================================================================
907 GObjectController *wxVtkSceneManager::GetGBlackBoxControlerPointedByMouse() {
908 GObjectController *result = NULL;
910 wxVTKRenderWindowInteractor *wxVTKiren;
912 = _vtkInteractorStyleBaseView->GetWxVtk3DBaseView()->GetWxVTKRenderWindowInteractor();
913 wxVTKiren->GetEventPosition(X, Y);
915 std::map<int, GObjectController*>::iterator it;
917 for (it = _controllers.begin(); it != _controllers.end(); ++it) {
918 GObjectController *cont = it->second;
919 int type = cont->getGObjectType();
921 if (cont->getView()->isPointInside(X, Y) == true) {
922 if (type == GBLACKBOX) {
925 } // if isPointInside
930 //=========================================================================
931 void wxVtkSceneManager::UnSelectBlackBoxes() {
932 for (int i = 0; i < (int) _selectedObjects.size(); i++) {
933 int id = _selectedObjects[i];
934 GObjectController* control = _controllers[id];
935 control->getView()->setState(NOTHING_HAPPENS);
936 }// for _selectedObjects
937 _selectedObjects.clear();
940 //=========================================================================
941 bool wxVtkSceneManager::OnLeftDClick() {
942 GObjectController *cont = GetGBlackBoxControlerPointedByMouse();
944 UnSelectBlackBoxes();
945 _parent->editBlackBox((GBlackBoxModel*) cont->getModel());
951 wxVTKRenderWindowInteractor *wxVTKiren;
952 wxVTKiren = _vtkInteractorStyleBaseView->GetWxVtk3DBaseView()->GetWxVTKRenderWindowInteractor();
953 wxVTKiren->GetEventPosition(X,Y);
955 std::map<int, GObjectController*>::iterator it;
957 bool clickOnObject = false;
959 for(it = _controllers.begin(); it != _controllers.end() && clickOnObject==false; ++it)
961 GObjectController *cont = it->second;
962 int type = cont->getGObjectType();
964 if(cont->getView()->isPointInside(X,Y))
968 for (int i=0; i< (int)_selectedObjects.size(); i++)
970 int id = _selectedObjects[i];
971 GObjectController* control = _controllers[id];
972 control->getView()->setState(NOTHING_HAPPENS);
974 _selectedObjects.clear();
976 GBlackBoxModel *bbmodel = (GBlackBoxModel*)cont->getModel();
977 _parent->editBlackBox(bbmodel);
979 clickOnObject = true;
983 if(clickOnObject==false)
985 //_parent->editDiagramParameters(this);
991 //=========================================================================
993 bool wxVtkSceneManager::OnChar() {
994 char keyCode = _vtkInteractorStyleBaseView->GetInteractor()-> GetKeyCode();
996 // KeyCode 127 : Delete Key
997 // KeyCode 8 : Backspace Key
998 if (keyCode == 8 || keyCode == 127) {
999 if (_selectedObjects.size() > 0) {
1000 for (int i = 0; i < (int) _selectedObjects.size(); i++) {
1001 int id = _selectedObjects[i];
1002 std::map<int, GObjectController*>::iterator it;
1003 it = _controllers.find(id);
1004 if (it != _controllers.end()) {
1008 _selectedObjects.clear();
1015 //=========================================================================
1017 void wxVtkSceneManager::AddControlerToBeRemove(
1018 std::vector<int> *controllersToRemove, int id) {
1022 for (i = 0; i < (int) controllersToRemove->size(); i++) {
1023 if (id == (*controllersToRemove)[i]) {
1029 controllersToRemove->push_back(id);
1034 //=========================================================================
1036 void wxVtkSceneManager::deleteObject(int id) {
1037 GObjectController *control = _controllers[id];
1038 std::vector<int> controllersToRemove;
1040 if (control->getGObjectType() == GBLACKBOX || control->getGObjectType()
1041 == GCOMPLEXINPUTPORT || control->getGObjectType()
1042 == GCOMPLEXOUTPUTPORT) {
1043 GBoxModel *bbmod = (GBoxModel*) control->getModel();
1044 std::vector<GPortModel*> inputs = bbmod->getInputPorts();
1046 bool boxConnected = false;
1048 // Add box input controllers to be removed
1049 for (int i = 0; i < (int) inputs.size(); i++) {
1050 AddControlerToBeRemove(&controllersToRemove,
1051 inputs[i]->getObjectId());
1052 if (inputs[i]->isConnected()) {
1053 boxConnected = true;
1057 std::vector<GPortModel*> outputs = bbmod->getOutputPorts();
1059 // Add box output controllers to be removed
1060 for (int i = 0; i < (int) outputs.size(); i++) {
1061 AddControlerToBeRemove(&controllersToRemove,
1062 outputs[i]->getObjectId());
1063 if (outputs[i]->isConnected()) {
1064 boxConnected = true;
1068 // Add connection controllers to be removed
1069 std::map<int, GObjectController*>::iterator it;
1070 for (it = _controllers.begin(); it != _controllers.end(); ++it) {
1071 GObjectController *cont = it->second;
1072 int type = cont->getGObjectType();
1073 if (type == GCONNECTOR) {
1074 GConnectorModel *conMod = (GConnectorModel*) cont->getModel();
1075 if (conMod->getStartPort() != NULL
1076 && conMod->getStartPort()->getParentBox()->getObjectId()
1077 == bbmod->getObjectId()) {
1078 AddControlerToBeRemove(&controllersToRemove,
1079 conMod->getObjectId());
1081 if (conMod->getEndPort() != NULL
1082 && conMod->getEndPort()->getParentBox()->getObjectId()
1083 == bbmod->getObjectId()) {
1084 AddControlerToBeRemove(&controllersToRemove,
1085 conMod->getObjectId());
1090 // Add box controller to be removed
1091 AddControlerToBeRemove(&controllersToRemove, bbmod->getObjectId());
1092 } else if (control->getGObjectType() == GCONNECTOR) {
1093 GConnectorModel *conMod = (GConnectorModel*) control->getModel();
1094 AddControlerToBeRemove(&controllersToRemove, conMod->getObjectId());
1097 std::map<int, GObjectController*>::iterator it;
1099 for (int i = 0; i < (int) controllersToRemove.size(); i++) {
1100 int key = controllersToRemove[i];
1101 it = _controllers.find(key);
1102 GObjectController *cont = _controllers[key];
1104 cont->removeFromScene();
1105 unregisterController((InteractorStyleMaracas*) cont);
1106 _controllers.erase(it);
1109 _parent->saveTempDiagram();
1112 //=========================================================================
1114 void wxVtkSceneManager::displayBlackBoxInfo(std::string packageName,
1115 std::string boxName) {
1116 _parent->displayBlackBoxInfo(packageName, boxName);
1119 //=========================================================================
1121 void wxVtkSceneManager::updateStatusBar(std::string textStatus) {
1122 _parent->updateStatusBar(textStatus);
1125 //=========================================================================
1126 std::string wxVtkSceneManager::LineNumber(bool withLineNumber, int &value) {
1127 std::string result = "";
1128 if (withLineNumber == true) {
1130 stringstream StrStream;
1132 std::string strValue = StrStream.str();
1135 } else if (value < 100) {
1139 result += strValue + ": ";
1143 //=========================================================================
1145 bool wxVtkSceneManager::MakeBoxExecutable() {
1146 std::map<int, GObjectController*> selected = getSelectedObjects();
1147 if( selected.empty() )
1150 std::map<int, GObjectController*>::iterator it;
1151 for (it = selected.begin(); it != selected.end(); ++it) {
1152 GObjectController* lastSelected = it->second;
1154 vtkGObjectView* view = (vtkGObjectView*) lastSelected->getView();
1155 GBlackBoxModel *bbmodel =
1156 (GBlackBoxModel*) lastSelected->getModel();
1157 view->setState(HIGHLIGHTED);
1158 if (bbmodel->isExecutable()) {
1159 bbmodel->setExecutable(false);
1161 bbmodel->setExecutable(true);
1163 bbmodel->notifyObservers(lastSelected->getId());
1171 //=========================================================================
1173 std::string wxVtkSceneManager::getDiagramBBS(bool wln) {
1174 bool existsExec = false;
1176 std::vector<std::string> packages;
1177 std::vector<int> boxes;
1178 std::vector<int> connections;
1179 std::vector<int> execBoxes;
1181 std::map<int, GObjectController*>::iterator it;
1183 for (it = _controllers.begin(); it != _controllers.end(); ++it) {
1184 GObjectController *desc = it->second;
1185 int type = desc->getGObjectType();
1187 if (type == GBLACKBOX) {
1188 GBlackBoxModel *mod = (GBlackBoxModel*) desc->getModel();
1190 std::string pkg = mod->getBBTKPackage();
1191 bool existsPkg = false;
1192 for (int t = 0; t < (int) packages.size() && existsPkg == false; t++) {
1193 if (packages[t] == pkg) {
1198 packages.push_back(pkg);
1201 boxes.push_back(it->first);
1202 if (mod->isExecutable()) {
1203 execBoxes.push_back(it->first);
1206 } else if (type == GCONNECTOR) {
1207 connections.push_back(it->first);
1212 std::string script = "";
1213 script += LineNumber(wln, lnNmbr) + "# BBTK GEditor Script\n";
1214 script += LineNumber(wln, lnNmbr) + "# ----------------------\n";
1215 script += LineNumber(wln, lnNmbr) + "\n";
1217 script += LineNumber(wln, lnNmbr) + "include std\n"; // EED
1218 script += LineNumber(wln, lnNmbr) + "include itkvtk\n"; // EED
1220 for (i = 0; i < (int) packages.size(); i++) {
1221 script += LineNumber(wln, lnNmbr);
1222 script += "include ";
1223 script += packages[i];
1227 script += LineNumber(wln, lnNmbr);
1232 script += LineNumber(wln, lnNmbr);
1233 script += "author \"";
1237 script += LineNumber(wln, lnNmbr);
1238 script += "description \"";
1239 script += _Description;
1242 script += LineNumber(wln, lnNmbr);
1243 script += "category \"";
1244 script += _Category;
1247 script += LineNumber(wln, lnNmbr);
1250 // script+="include std\n"; // JPR
1252 for (i = 0; i < (int) boxes.size(); i++) {
1253 script += LineNumber(wln, lnNmbr);
1256 GObjectController *control = _controllers[id];
1257 GBlackBoxModel *model = (GBlackBoxModel*) control->getModel();
1259 script += model->getBBTKType();
1261 script += model->getBBTKName();
1264 std::vector<GPortModel*> inputs = model->getInputPorts();
1265 for (int j = 0; j < (int) inputs.size(); j++) {
1266 GPortModel* inputPort = inputs[j];
1267 if (inputPort->isValueSet()) {
1268 script += LineNumber(wln, lnNmbr);
1270 script += model->getBBTKName();
1272 script += inputPort->getBBTKName();
1274 script += inputPort->getValue();
1279 script += LineNumber(wln, lnNmbr);
1284 script += LineNumber(wln, lnNmbr);
1287 for (i = 0; i < (int) connections.size(); i++) {
1288 script += LineNumber(wln, lnNmbr);
1289 script += "connect ";
1290 int id = connections[i];
1291 GObjectController *control = _controllers[id];
1292 GConnectorModel *model = (GConnectorModel*) control->getModel();
1294 //Start Connection info
1295 GPortModel *start = model->getStartPort();
1296 script += start->getParentBox()->getBBTKName();
1298 script += start->getBBTKName();
1302 //End Connection info
1303 GPortModel *end = model->getEndPort();
1304 script += end->getParentBox()->getBBTKName();
1306 script += end->getBBTKName();
1311 script += LineNumber(wln, lnNmbr);
1313 for (i = 0; i < (int) execBoxes.size(); i++) {
1314 script += LineNumber(wln, lnNmbr);
1316 int id = execBoxes[i];
1317 GObjectController *control = _controllers[id];
1318 GBlackBoxModel *model = (GBlackBoxModel*) control->getModel();
1320 script += model->getBBTKName();
1329 //=========================================================================
1331 std::string wxVtkSceneManager::saveComplexBoxBBS() {
1332 std::vector<std::string> packages;
1333 std::vector<int> boxes;
1334 std::vector<int> connections;
1335 std::vector<int> execBoxes;
1337 std::map<int, GObjectController*>::iterator it;
1339 for (it = _controllers.begin(); it != _controllers.end(); ++it) {
1340 GObjectController *desc = it->second;
1341 int type = desc->getGObjectType();
1343 if (type == GBLACKBOX) {
1344 GBlackBoxModel *mod = (GBlackBoxModel*) desc->getModel();
1346 std::string pkg = mod->getBBTKPackage();
1347 bool existsPkg = false;
1348 for (int t = 0; t < (int) packages.size() && existsPkg == false; t++) {
1349 if (packages[t] == pkg) {
1354 packages.push_back(pkg);
1357 boxes.push_back(it->first);
1358 if (mod->isExecutable()) {
1359 execBoxes.push_back(it->first);
1361 } else if (type == GCONNECTOR) {
1362 connections.push_back(it->first);
1366 std::string script = "";
1368 script += "include std\n"; // EED
1369 script += "include itkvtk\n"; // EED
1371 for (i = 0; i < (int) packages.size(); i++) {
1372 script += "include ";
1373 script += packages[i];
1378 // Definition of a complex box
1379 script += "define ";
1380 script += _cbName + " " + _cbPackageName;
1384 script += "author \"";
1388 script += "description \"";
1389 script += _Description;
1393 script += "category \"";
1394 script += _Category;
1399 for (i = 0; i < (int) boxes.size(); i++) {
1402 GObjectController *control = _controllers[id];
1403 GBlackBoxModel *model = (GBlackBoxModel*) control->getModel();
1405 script += model->getBBTKType();
1407 script += model->getBBTKName();
1410 std::vector<GPortModel*> inputs = model->getInputPorts();
1411 for (int j = 0; j < (int) inputs.size(); j++) {
1412 GPortModel* inputPort = inputs[j];
1413 if (inputPort->isValueSet()) {
1415 script += model->getBBTKName();
1417 script += inputPort->getBBTKName();
1419 script += inputPort->getValue();
1427 // Create connections in the script. If the connection is made with a complex port, it is created the input or output
1429 std::string complexInputs = "";
1430 std::string complexOutputs = "";
1433 for (i = 0; i < (int) connections.size(); i++) {
1434 int id = connections[i];
1435 GObjectController *control = _controllers[id];
1436 GConnectorModel *model = (GConnectorModel*) control->getModel();
1439 GPortModel *start = model->getStartPort();
1440 GBoxModel *startBox = start->getParentBox();
1442 GPortModel *end = model->getEndPort();
1443 GBoxModel *endBox = end->getParentBox();
1445 if (startBox->getGObjectType() == GCOMPLEXINPUTPORT) {
1446 complexInputs += "input ";
1447 complexInputs += startBox->getBBTKName();
1449 complexInputs += " ";
1450 complexInputs += endBox->getBBTKName();
1451 complexInputs += ".";
1452 complexInputs += end->getBBTKName();
1454 complexInputs += " ";
1455 complexInputs += "\" \"";
1457 complexInputs += "\n";
1458 } else if (endBox->getGObjectType() == GCOMPLEXOUTPUTPORT) {
1459 complexOutputs += "output ";
1460 complexOutputs += endBox->getBBTKName();
1462 complexOutputs += " ";
1463 complexOutputs += startBox->getBBTKName();
1464 complexOutputs += ".";
1465 complexOutputs += start->getBBTKName();
1467 complexOutputs += " ";
1468 complexOutputs += "\" \"";
1470 complexOutputs += "\n";
1472 script += "connect ";
1473 script += startBox->getBBTKName();
1475 script += start->getBBTKName();
1479 //End Connection info
1480 script += endBox->getBBTKName();
1482 script += end->getBBTKName();
1490 for (i = 0; i < (int) execBoxes.size(); i++) {
1492 int id = execBoxes[i];
1493 GObjectController *control = _controllers[id];
1494 GBlackBoxModel *model = (GBlackBoxModel*) control->getModel();
1496 script += model->getBBTKName();
1501 script += "# Complex input ports\n";
1502 script += complexInputs;
1505 script += "# Complex output ports\n";
1506 script += complexOutputs;
1509 script += "endefine";
1515 //=========================================================================
1517 void wxVtkSceneManager::deleteAllBoxes() {
1518 std::map<int, GObjectController*>::iterator it;
1519 for (it = _controllers.begin(); it != _controllers.end(); ++it) {
1520 GObjectController *cont = it->second;
1521 cont->removeFromScene();
1522 unregisterController((InteractorStyleMaracas*) cont);
1524 _selectedObjects.clear();
1525 _controllers.clear();
1529 //=========================================================================
1532 void wxVtkSceneManager::refresh() {
1533 _baseView->Refresh();
1535 //=========================================================================
1537 void wxVtkSceneManager::refreshScene() {
1538 _baseView->RefreshView();
1541 //=========================================================================
1543 void wxVtkSceneManager::centerView() {
1545 _baseView->GetRenderer()->GetActiveCamera()->GetFocalPoint(temp);
1546 _baseView->GetRenderer()->GetActiveCamera()->SetFocalPoint(0, 0, temp[2]);
1547 _baseView->GetRenderer()->GetActiveCamera()->GetPosition(temp);
1548 _baseView->GetRenderer()->GetActiveCamera()->SetPosition(0, 0, temp[2]);
1549 _baseView->RefreshView();
1553 //=========================================================================
1555 void wxVtkSceneManager::saveDiagram(std::string &content) {
1558 content += "CATEGORY:";
1559 content += GetCategory();
1562 content += "DESCRIPTION:";
1563 content += GetDescription();
1566 content += "AUTHOR:";
1567 content += GetAuthor();
1570 //Print info IF COMPLEX BOX
1571 content += "COMPLEXBOX:";
1572 if (_isComplexBox) {
1573 content += "TRUE\n";
1575 content += "COMPLEXBOXNAME:";
1576 content += GetCbName();
1579 content += "PACKAGENAME:";
1580 content += GetCbPackageName();
1583 //Print info complex input ports
1584 std::vector<int> inputs = getComplexInputPorts();
1585 int insize = inputs.size();
1586 content += "COMPLEXINPUTS:";
1587 sprintf(buffer, "%d", insize);
1591 for (int i = 0; i < insize; i++) {
1593 GObjectController *cont = _controllers[id];
1594 cont->getModel()->save(content);
1597 //Print info complex output ports
1598 std::vector<int> outputs = getComplexOutputPorts();
1599 int outsize = outputs.size();
1600 content += "COMPLEXOUTPUTS:";
1601 sprintf(buffer, "%d", outsize);
1605 for (int i = 0; i < outsize; i++) {
1606 int id = outputs[i];
1607 GObjectController *cont = _controllers[id];
1608 cont->getModel()->save(content);
1612 content += "FALSE\n";
1616 std::vector<int> boxes = getBlackBoxes();
1617 int bsize = boxes.size();
1618 content += "BOXES:";
1619 sprintf(buffer, "%d", bsize);
1623 for (int i = 0; i < bsize; i++) {
1625 GObjectController *cont = _controllers[id];
1626 cont->getModel()->save(content);
1630 std::vector<int> connections = getConnections();
1631 int csize = connections.size();
1632 content += "CONNECTIONS:";
1633 sprintf(buffer, "%d", csize);
1637 for (int i = 0; i < csize; i++) {
1638 int id = connections[i];
1639 GObjectController *cont = _controllers[id];
1640 cont->getModel()->save(content);
1645 //=========================================================================
1647 void wxVtkSceneManager::loadDiagram(stringstream &inputStream) {
1649 std::string version = "<void>";
1650 std::string line = "";
1651 char delims[] = ":";
1652 char *result = NULL;
1654 getline(inputStream, line);
1657 while (!inputStream.eof()) {
1658 if (line == "" || line[0] == '#') {
1659 getline(inputStream, line);
1660 if (line == "# - BBTKGEditor v 1.0 BBG BlackBox Diagram file") {
1661 version = line.substr(18, 3);
1663 if (line == "# - BBTKGEditor v 1.1 BBG BlackBox Diagram file") {
1664 version = line.substr(18, 3);
1666 if (line == "# - BBTKGEditor v 1.2 BBG BlackBox Diagram file") {
1667 version = line.substr(18, 3);
1669 } else if (line == "APP_START") {
1675 printf("EED wxVtkSceneManager::loadDiagram version=%s\n", version.c_str());
1679 if ((version != "1.0") && (version != "1.1")) {
1680 getline(inputStream, line);//CATEGORY:<category of the box>
1681 char categoryTmp[30];
1682 strcpy(categoryTmp, line.c_str());
1683 result = strtok(categoryTmp, delims);
1684 result = strtok(NULL, delims);
1685 SetCategory(result);
1687 getline(inputStream, line);//DESCRIPTION:<description of the box>
1688 char descriptionTmp[1024];
1689 strcpy(descriptionTmp, line.c_str());
1690 result = strtok(descriptionTmp, delims);
1691 result = strtok(NULL, delims);
1692 SetDescription(result);
1694 getline(inputStream, line);//AUTHOR:<author>
1695 char authorTmp[255];
1696 strcpy(authorTmp, line.c_str());
1697 result = strtok(authorTmp, delims);
1698 result = strtok(NULL, delims);
1703 getline(inputStream, line);//COMPLEX_BOX:TRUE|FALSE
1704 char complexTmp[30];
1705 strcpy(complexTmp, line.c_str());
1706 result = strtok(complexTmp, delims);
1707 result = strtok(NULL, delims);
1708 std::string isComplexBox(result);
1710 if (isComplexBox == "TRUE") {
1711 _isComplexBox = true;
1713 if ((version != "1.0") && (version != "1.1")) {
1714 getline(inputStream, line);//COMPLEXNAME:<name of the complex box>
1715 char complexboxnameTmp[255];
1716 strcpy(complexboxnameTmp, line.c_str());
1717 result = strtok(complexboxnameTmp, delims);
1718 result = strtok(NULL, delims);
1721 getline(inputStream, line);//PACKAGENAME:<name of the package of the box>
1722 char packagenameTmp[255];
1723 strcpy(packagenameTmp, line.c_str());
1724 result = strtok(packagenameTmp, delims);
1725 result = strtok(NULL, delims);
1726 SetCbPackageName(result);
1729 //-----------------------
1730 //- COMPLEX INPUT PORTS
1731 //-----------------------
1732 getline(inputStream, line);//COMPLEXINPUTS:num
1734 strcpy(inputs, line.c_str());
1735 result = strtok(inputs, delims);
1736 result = strtok(NULL, delims);
1739 std::istringstream inps(result);
1742 for (int i = 0; i < numInputs; i++) {
1744 getline(inputStream, line);//COMPLEX_PORT
1745 getline(inputStream, line);//name
1746 std::string inputPortName(line);
1749 getline(inputStream, line);//xInic:yInic:zInic
1751 strcpy(coord, line.c_str());
1752 result = strtok(coord, delims);//xInic
1753 std::string xInic(result);
1754 result = strtok(NULL, delims);//yInic
1755 std::string yInic(result);
1756 result = strtok(NULL, delims);//zInic
1757 std::string zInic(result);
1759 double xIn, yIn, zIn;
1760 std::istringstream xSt(xInic);
1762 std::istringstream ySt(yInic);
1764 std::istringstream zSt(zInic);
1767 getline(inputStream, line);//FIN_COMPLEX_PORT
1769 configGComBoxInputOutputPort(true, inputPortName, xIn, yIn, zIn);
1771 } // for input complex box
1774 //-----------------------
1775 //- COMPLEX OUTPUT PORTS
1776 //-----------------------
1778 getline(inputStream, line);//COMPLEXOUTPUTS:num
1780 strcpy(outputs, line.c_str());
1781 result = strtok(outputs, delims);
1782 result = strtok(NULL, delims);
1785 std::istringstream outps(result);
1786 outps >> numOutputs;
1788 for (int i = 0; i < numOutputs; i++) {
1790 getline(inputStream, line);//COMPLEX_PORT
1791 getline(inputStream, line);//name
1792 std::string outputPortName(line);
1795 getline(inputStream, line);//xInic:yInic:zInic
1797 strcpy(coord, line.c_str());
1798 result = strtok(coord, delims);//xInic
1799 std::string xInic(result);
1800 result = strtok(NULL, delims);//yInic
1801 std::string yInic(result);
1802 result = strtok(NULL, delims);//zInic
1803 std::string zInic(result);
1805 double xIn, yIn, zIn;
1806 std::istringstream xSt(xInic);
1808 std::istringstream ySt(yInic);
1810 std::istringstream zSt(zInic);
1813 getline(inputStream, line);//FIN_COMPLEX_PORT
1815 configGComBoxInputOutputPort(false, outputPortName, xIn, yIn,
1818 } // for output complex box
1823 getline(inputStream, line);//BOXES:num
1825 strcpy(boxes, line.c_str());
1826 result = strtok(boxes, delims);
1827 result = strtok(NULL, delims);
1830 std::istringstream is(result);
1833 for (int i = 0; i < numBoxes; i++) {
1835 getline(inputStream, line);//BOX
1836 getline(inputStream, line);//package:type:name
1838 strcpy(box, line.c_str());
1839 result = strtok(box, delims);//package
1840 std::string package(result);
1841 result = strtok(NULL, delims);//type
1842 std::string type(result);
1843 result = strtok(NULL, delims);//name
1844 std::string name(result);
1846 getline(inputStream, line);//ISEXEC:TRUE|FALSE
1848 strcpy(exec, line.c_str());
1849 result = strtok(exec, delims);//ISEXEC
1850 result = strtok(NULL, delims);//TRUE|FALSE
1851 std::string isExec(result);
1854 getline(inputStream, line);//xInic:yInic:zInic
1856 strcpy(coord, line.c_str());
1857 result = strtok(coord, delims);//xInic
1858 std::string xInic(result);
1859 result = strtok(NULL, delims);//yInic
1860 std::string yInic(result);
1861 result = strtok(NULL, delims);//zInic
1862 std::string zInic(result);
1864 double xIn, yIn, zIn;
1865 std::istringstream xSt(xInic);
1867 std::istringstream ySt(yInic);
1869 std::istringstream zSt(zInic);
1873 getline(inputStream, line);//xEnd:yEnd:zEnd
1874 strcpy(coord, line.c_str());
1875 result = strtok(coord, delims);//xEnd
1876 std::string xEnd(result);
1877 result = strtok(NULL, delims);//yEnd
1878 std::string yEnd(result);
1879 result = strtok(NULL, delims);//zEnd
1880 std::string zEnd(result);
1882 double xEn, yEn, zEn;
1883 std::istringstream xEt(xEnd);
1885 std::istringstream yEt(yEnd);
1887 std::istringstream zEt(zEnd);
1890 bool boxExecutable = false;
1891 if (isExec == "TRUE") {
1892 boxExecutable = true;
1895 int idBox = createGBlackBox(xIn, yIn, package, type);
1896 configGBlackBox(idBox, xIn, yIn, zIn, name, boxExecutable, xEn,
1899 GObjectController *cont = _controllers[idBox];
1900 GBlackBoxModel *bbmod = (GBlackBoxModel*) cont->getModel();
1903 getline(inputStream, line);//PORT o FIN_BOX
1904 std::string port = line.substr(0, 4);
1905 while (port == "PORT") {
1906 getline(inputStream, line);//name:value
1908 strcpy(poort, line.c_str());
1909 result = strtok(poort, delims);//name
1910 std::string name(result);
1911 result = strtok(NULL, delims);//value
1912 std::string value(result);
1914 bbmod->setValueToInput(name, value);
1916 getline(inputStream, line);//PORT o FIN_BOX
1917 port = line.substr(0, 4);
1920 //EED bbmod->notifyObservers(_idManager);
1925 getline(inputStream, line);//CONNECTIONS:num
1927 strcpy(conns, line.c_str());
1928 result = strtok(conns, delims);
1929 result = strtok(NULL, delims);
1932 std::istringstream isCons(result);
1935 for (int i = 0; i < numConns; i++) {
1937 getline(inputStream, line);//CONNECTION
1938 getline(inputStream, line);//Startbox.PortName:EndBox.PortName
1941 strcpy(connec, line.c_str());
1942 result = strtok(connec, delims);
1943 std::string nameStartBox(result);
1944 result = strtok(NULL, delims);
1945 std::string nameStartPort(result);
1946 result = strtok(NULL, delims);
1947 std::string nameEndBox(result);
1948 result = strtok(NULL, delims);
1949 std::string nameEndPort(result);
1951 int idCon = configGConnetion(nameStartBox, nameStartPort,
1952 nameEndBox, nameEndPort);
1954 if (version != "1.0") {
1955 //Readding control points of the manualContour
1957 GConnectorController *tempp =
1958 (GConnectorController*) _controllers[idCon];
1959 GConnectorModel *conMod = (GConnectorModel*) tempp->getModel();
1960 vtkGConnectorView *conView =
1961 (vtkGConnectorView*) tempp->getView();
1962 getline(inputStream, line); //NumberOfControlPoints:##
1963 strcpy(conns, line.c_str());
1964 result = strtok(conns, delims);
1965 result = strtok(NULL, delims);
1967 int numberOfControlPoints;
1968 std::istringstream isCons(result);
1969 isCons >> numberOfControlPoints;
1971 for (int ii = 0; ii < numberOfControlPoints; ii++) {
1972 getline(inputStream, line); //XX:YY:ZZ
1974 strcpy(connec, line.c_str());
1977 result = strtok(connec, delims);
1978 std::istringstream isPointX(result);
1980 result = strtok(NULL, delims);
1981 std::istringstream isPointY(result);
1983 result = strtok(NULL, delims);
1984 std::istringstream isPointZ(result);
1987 conMod->getManualContourModel()->InsertPoint_id(ii + 1, px,
1989 conView->getManualContourView()->AddPoint();
1999 //=========================================================================
2002 //=========================================================================
2003 void wxVtkSceneManager::configGComBoxInputOutputPort(bool inputoutput,
2004 std::string portName, double xIn, double yIn, double zIn) {
2006 if (inputoutput == true) {
2007 idPort = createGComplexBoxInputPort(portName);
2009 idPort = createGComplexBoxOutputPort(portName);
2011 GObjectController *cont = _controllers[idPort];
2012 GBoxModel *cbmod = (GBoxModel*) cont->getModel();
2013 cbmod->setInicPoint(xIn, yIn, zIn);
2014 cbmod->notifyObservers(_idManager);
2016 //=========================================================================
2019 //=========================================================================
2020 GBoxModel* wxVtkSceneManager::findGBox(std::string boxname) {
2024 GBoxModel *boxModel = NULL;
2025 std::vector<int> lstB = getBlackBoxes();
2026 for (j = 0; j < (int) lstB.size(); j++) {
2028 bMod = (GBoxModel*) _controllers[idB]->getModel();
2029 if (_controllers[idB]->getModel()->getBBTKName() == boxname) {
2034 if ((_isComplexBox) && (boxModel == NULL)) {
2035 std::vector<int> lstInputs = getComplexInputPorts();
2036 for (j = 0; j < (int) lstInputs.size(); j++) {
2038 bMod = (GBoxModel*) _controllers[idB]->getModel();
2039 if (_controllers[idB]->getModel()->getBBTKName() == boxname) {
2044 std::vector<int> lstOutputs = getComplexOutputPorts();
2045 for (j = 0; j < (int) lstOutputs.size(); j++) {
2046 int idB = lstOutputs[j];
2047 bMod = (GBoxModel*) _controllers[idB]->getModel();
2048 if (_controllers[idB]->getModel()->getBBTKName() == boxname) {
2058 //=========================================================================
2061 int wxVtkSceneManager::configGConnetion(std::string nameStartBox,
2062 std::string nameStartPort, std::string nameEndBox,
2063 std::string nameEndPort) {
2065 GBoxModel *boxModel;
2066 GPortModel *startP = NULL;
2067 GPortModel *endP = NULL;
2069 boxModel = findGBox(nameStartBox);
2070 if (boxModel != NULL) {
2071 startP = boxModel->getOutputPort(nameStartPort);
2074 boxModel = findGBox(nameEndBox);
2075 if (boxModel != NULL) {
2076 endP = boxModel->getInputPort(nameEndPort);
2080 int idCon = createGConnector(startP);
2081 _worldState = NOTHING_HAPPENS;
2082 GConnectorController *tempp = (GConnectorController*) _controllers[idCon];
2084 GConnectorModel *conMod = (GConnectorModel*) tempp->getModel();
2085 vtkGConnectorView *conView = (vtkGConnectorView*) tempp->getView();
2086 tempp->endContourCreation();
2087 conMod->setEndPort(endP);
2088 conView->updateStartEndPoints();
2092 //=========================================================================
2094 bool wxVtkSceneManager::boxExist(std::string boxname) {
2096 std::map<int, GObjectController*>::iterator it;
2097 for (it = _controllers.begin(); it != _controllers.end(); ++it) {
2098 GObjectController *cont = it->second;
2099 if (cont->getModel()->getBBTKName() == boxname) {
2106 //=========================================================================
2108 std::vector<int> wxVtkSceneManager::getBlackBoxes() {
2109 std::vector<int> vect;
2110 std::map<int, GObjectController*>::iterator it;
2111 for (it = _controllers.begin(); it != _controllers.end(); ++it) {
2112 GObjectController *cont = it->second;
2113 if (cont->getGObjectType() == GBLACKBOX) {
2114 vect.push_back(cont->getId());
2120 //=========================================================================
2122 std::vector<int> wxVtkSceneManager::getComplexInputPorts() {
2123 std::vector<int> vect;
2124 std::map<int, GObjectController*>::iterator it;
2125 for (it = _controllers.begin(); it != _controllers.end(); ++it) {
2126 GObjectController *cont = it->second;
2127 if (cont->getGObjectType() == GCOMPLEXINPUTPORT) {
2128 vect.push_back(cont->getId());
2134 //=========================================================================
2136 std::vector<int> wxVtkSceneManager::getComplexOutputPorts() {
2137 std::vector<int> vect;
2138 std::map<int, GObjectController*>::iterator it;
2139 for (it = _controllers.begin(); it != _controllers.end(); ++it) {
2140 GObjectController *cont = it->second;
2141 if (cont->getGObjectType() == GCOMPLEXOUTPUTPORT) {
2142 vect.push_back(cont->getId());
2148 //=========================================================================
2150 std::vector<int> wxVtkSceneManager::getConnections() {
2151 std::vector<int> vect;
2152 std::map<int, GObjectController*>::iterator it;
2153 for (it = _controllers.begin(); it != _controllers.end(); ++it) {
2154 GObjectController *cont = it->second;
2155 if (cont->getGObjectType() == GCONNECTOR) {
2156 vect.push_back(cont->getId());
2162 //=========================================================================
2164 bool wxVtkSceneManager::isComplexBox() {
2165 return _isComplexBox;
2168 //=========================================================================
2170 void wxVtkSceneManager::setComplexBox(bool val) {
2171 _isComplexBox = val;
2174 //=========================================================================
2176 int wxVtkSceneManager::addObjectController(GObjectController* objController) {
2177 //Register the controller of the new object
2178 registerController((InteractorStyleMaracas*) objController);
2179 //Add the object to the objects list
2180 int newId = _contLastId;//_controllers.size();
2181 objController->setId(newId);
2182 _controllers[newId] = objController;
2184 << "DFCH: int wxVtkSceneManager::addObjectController(GObjectController* objController) ---- _contLastId = "
2185 << _contLastId << std::endl;
2190 //=========================================================================
2192 int wxVtkSceneManager::getNumSelectedObjects() {
2193 return _selectedObjects.size();
2196 //=========================================================================
2198 std::map<int, GObjectController*> wxVtkSceneManager::getSelectedObjects() {
2199 std::map<int, GObjectController*> mapSelected;
2201 std::map<int, GObjectController*>::iterator it;
2202 for (it = _controllers.begin(); it != _controllers.end(); ++it) {
2203 GObjectController *cont = it->second;
2204 if (cont->getGObjectType() == GBLACKBOX && cont->getView()->getState()
2206 mapSelected[cont->getId()] = cont;
2210 std::map<int, GObjectController*>::iterator it2;
2211 for (it2 = _controllers.begin(); it2 != _controllers.end(); ++it2) {
2212 GObjectController *cont = it2->second;
2213 if (cont->getGObjectType() == GCONNECTOR) {
2214 GConnectorModel* cmod = (GConnectorModel*) cont->getModel();
2215 GBoxModel* endPortParentBox = cmod->getEndPort()->getParentBox();
2216 GBoxModel* startPortParentBox =
2217 cmod->getStartPort()->getParentBox();
2219 std::map<int, GObjectController*>::iterator iterOBJ1 =
2220 mapSelected.find(startPortParentBox->getObjectId());
2221 std::map<int, GObjectController*>::iterator iterOBJ2 =
2222 mapSelected.find(endPortParentBox->getObjectId());
2224 if (iterOBJ1 != mapSelected.end() && iterOBJ2 != mapSelected.end()) {
2225 int ID = cont->getId();
2226 mapSelected[ID] = cont;
2233 //=========================================================================
2235 void wxVtkSceneManager::addObjects(std::map<int, GObjectController*> objectsMap) {
2237 std::map<int, int> oldIdNewIdBoxes;
2238 std::vector<int> connections;
2240 std::map<int, GObjectController*>::iterator it;
2241 for (it = objectsMap.begin(); it != objectsMap.end(); ++it) {
2242 GObjectController *cont = it->second;
2243 int type = cont->getGObjectType();
2245 if (type == GBLACKBOX) {
2247 double xInic, yInic, zInic;
2248 GBlackBoxModel* copyBox = (GBlackBoxModel*) cont->getModel();
2249 copyBox->getInicPoint(xInic, yInic, zInic);
2250 int idBox = createGBlackBox(0, 0, copyBox->getBBTKPackage(),
2251 copyBox->getBBTKType());
2253 int idcB = copyBox->getObjectId();
2254 oldIdNewIdBoxes[idcB] = idBox;
2255 cont = _controllers[idBox];
2256 GBlackBoxModel* newbox = (GBlackBoxModel*) cont->getModel();
2257 newbox->setInicPoint(xInic, yInic, zInic);
2258 int num = newbox->getNumInputPorts();
2259 for (int j = 0; j < num; j++) {
2260 newbox->setValueToInputPort(j, copyBox->getValueInputPort(j));
2262 newbox->notifyObservers(_idManager);
2263 } else if (type == GCONNECTOR) {
2264 int idCon = cont->getId();
2265 connections.push_back(idCon);
2270 for (int i = 0; i < (int) connections.size(); i++) {
2271 int objId = connections[i];
2272 GObjectController *cont = objectsMap[objId];
2273 GConnectorModel* connectModel = (GConnectorModel*) cont->getModel();
2275 GPortModel* startPort = connectModel->getStartPort();
2276 int startPortIndex = startPort->getPosInBox();
2277 GPortModel* endPort = connectModel->getEndPort();
2278 int endPortIndex = endPort->getPosInBox();
2280 GBlackBoxModel* startPortParentBox =
2281 (GBlackBoxModel*) startPort->getParentBox();
2282 GBlackBoxModel* endPortParentBox =
2283 (GBlackBoxModel*) endPort->getParentBox();
2285 int idNewStartBox = oldIdNewIdBoxes[startPortParentBox->getObjectId()];
2286 int idNewEndBox = oldIdNewIdBoxes[endPortParentBox->getObjectId()];
2288 GBlackBoxModel* newStartBox =
2289 (GBlackBoxModel*) _controllers[idNewStartBox]->getModel();
2290 GBlackBoxModel* newEndBox =
2291 (GBlackBoxModel*) _controllers[idNewEndBox]->getModel();
2293 GPortModel* newStartPort = newStartBox->getOutputPort(startPortIndex);
2294 GPortModel* newEndPort = newEndBox->getInputPort(endPortIndex);
2296 // Creates connection
2297 int idCon = createGConnector(newStartPort);
2298 GConnectorController *tempp =
2299 (GConnectorController*) _controllers[idCon];
2300 GConnectorModel *conMod = (GConnectorModel*) tempp->getModel();
2301 vtkGConnectorView *conView = (vtkGConnectorView*) tempp->getView();
2302 tempp->endContourCreation();
2303 conMod->setEndPort(newEndPort);
2304 conView->updateStartEndPoints();
2307 std::map<int, int>::iterator itIds;
2308 for (itIds = oldIdNewIdBoxes.begin(); itIds != oldIdNewIdBoxes.end(); ++itIds) {
2309 int idOld = itIds->first;
2310 int idNew = itIds->second;
2312 GBlackBoxModel* oldBox =
2313 (GBlackBoxModel*) objectsMap[idOld]->getModel();
2314 GBlackBoxModel* newBox =
2315 (GBlackBoxModel*) _controllers[idNew]->getModel();
2317 std::vector<int> oldInputConnections = oldBox->getConnectedInputs();
2318 std::vector<int> oldOutputConnections = oldBox->getConnectedOutputs();
2319 std::vector<int> newInputConnections = newBox->getConnectedInputs();
2320 std::vector<int> newOutputConnections = newBox->getConnectedOutputs();
2322 for (int k = 0; k < (int) oldInputConnections.size(); k++) {
2324 //EED int toCreate=-1;
2325 for (int l = 0; l < (int) newInputConnections.size() && !exist; l++) {
2326 if (oldInputConnections[k] == newInputConnections[l]) {
2331 if (exist == false) {
2332 //Create complex input
2333 int posInBox = oldInputConnections[k];
2334 GPortModel* inputPort = oldBox->getInputPort(posInBox);
2335 std::string inputPortName = inputPort->getBBTKName();
2336 int idInputPort = createGComplexBoxInputPort(inputPortName);
2337 GObjectController *cont = _controllers[idInputPort];
2338 GBoxModel *cbmod = (GBoxModel*) cont->getModel();
2339 double xIn, yIn, zIn;
2340 inputPort->getInicPoint(xIn, yIn, zIn);
2342 cbmod->setInicPoint(xIn, yIn, zIn);
2343 cbmod->notifyObservers(_idManager);
2345 GPortModel* inputPortEnd = newBox->getInputPort(posInBox);
2347 // Creates connection
2348 int idCon = createGConnector(cbmod->getOutputPort(0));
2349 GConnectorController *tempp =
2350 (GConnectorController*) _controllers[idCon];
2351 GConnectorModel *conMod = (GConnectorModel*) tempp->getModel();
2352 vtkGConnectorView *conView =
2353 (vtkGConnectorView*) tempp->getView();
2354 tempp->endContourCreation();
2355 conMod->setEndPort(inputPortEnd);
2356 conView->updateStartEndPoints();
2362 for (int k = 0; k < (int) oldOutputConnections.size(); k++) {
2364 //EED int toCreate=-1;
2365 for (int l = 0; l < (int) newOutputConnections.size() && !exist; l++) {
2366 if (oldOutputConnections[k] == newOutputConnections[l]) {
2371 if (exist == false) {
2372 //Create complex output
2373 int posInBox = oldOutputConnections[k];
2374 GPortModel* outputPort = oldBox->getOutputPort(posInBox);
2375 std::string outputPortName = outputPort->getBBTKName();
2376 int idOutputPort = createGComplexBoxOutputPort(outputPortName);
2377 GObjectController *cont = _controllers[idOutputPort];
2378 GBoxModel *cbmod = (GBoxModel*) cont->getModel();
2379 double xIn, yIn, zIn;
2380 outputPort->getInicPoint(xIn, yIn, zIn);
2382 cbmod->setInicPoint(xIn, yIn, zIn);
2383 cbmod->notifyObservers(_idManager);
2385 GPortModel* outputPortEnd = newBox->getOutputPort(posInBox);
2387 // Creates connection
2388 int idCon = createGConnector(outputPortEnd);
2389 GConnectorController *tempp =
2390 (GConnectorController*) _controllers[idCon];
2391 GConnectorModel *conMod = (GConnectorModel*) tempp->getModel();
2392 vtkGConnectorView *conView =
2393 (vtkGConnectorView*) tempp->getView();
2394 tempp->endContourCreation();
2395 conMod->setEndPort(cbmod->getInputPort(0));
2396 conView->updateStartEndPoints();
2406 //=========================================================================
2407 void wxVtkSceneManager::SetCbName(std::string cbName) {
2409 if (_cbName == "") {
2410 _cbName = "<complex box name>";
2414 //=========================================================================
2415 std::string wxVtkSceneManager::GetCbName() {
2419 //=========================================================================
2420 void wxVtkSceneManager::SetCbPackageName(std::string packagename) {
2421 _cbPackageName = packagename;
2422 if (_cbPackageName == "") {
2423 _cbPackageName = "<package name of the complex box>";
2427 //=========================================================================
2428 std::string wxVtkSceneManager::GetCbPackageName() {
2429 return _cbPackageName;
2432 //=========================================================================
2433 void wxVtkSceneManager::SetAuthor(std::string author) {
2435 if (_Author == "") {
2436 _Author = "<author of the box>";
2440 //=========================================================================
2441 std::string wxVtkSceneManager::GetAuthor() {
2445 //=========================================================================
2446 void wxVtkSceneManager::SetCategory(std::string category) {
2447 _Category = category;
2448 if (_Category == "") {
2449 _Category = "<category of the box>";
2453 //=========================================================================
2454 std::string wxVtkSceneManager::GetCategory() {
2458 //=========================================================================
2459 void wxVtkSceneManager::SetDescription(std::string description) {
2460 _Description = description;
2461 if (_Description == "") {
2462 _Description = "<description of the box>";
2466 //=========================================================================
2467 std::string wxVtkSceneManager::GetDescription() {
2468 return _Description;
2471 //=========================================================================
2474 } // EO namespace bbtk