GOFIGURE2  0.9.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
QGoSynchronizedViewManager.cxx
Go to the documentation of this file.
1 /*=========================================================================
2  Authors: The GoFigure Dev. Team.
3  at Megason Lab, Systems biology, Harvard Medical school, 2009-11
4 
5  Copyright (c) 2009-11, President and Fellows of Harvard College.
6  All rights reserved.
7 
8  Redistribution and use in source and binary forms, with or without
9  modification, are permitted provided that the following conditions are met:
10 
11  Redistributions of source code must retain the above copyright notice,
12  this list of conditions and the following disclaimer.
13  Redistributions in binary form must reproduce the above copyright notice,
14  this list of conditions and the following disclaimer in the documentation
15  and/or other materials provided with the distribution.
16  Neither the name of the President and Fellows of Harvard College
17  nor the names of its contributors may be used to endorse or promote
18  products derived from this software without specific prior written
19  permission.
20 
21  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
23  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
24  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
25  BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
26  OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
27  OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
28  OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
29  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
30  OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
31  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 
33 =========================================================================*/
35 
36 #include "QGoSynchronizedView2D.h"
37 #include "QGoSynchronizedView3D.h"
40 #include <algorithm>
41 
42 //--------------------------------------------------------------------------
44  QObject (iParent),
45  m_Synchronizer (NULL),
46  m_Synchronizer3D (NULL)
47 {
48 }
49 
50 //--------------------------------------------------------------------------
51 //--------------------------------------------------------------------------
54 {
55  std::vector< QGoSynchronizedView2D * >::iterator SynchronizedViewIt;
56  std::vector< QGoSynchronizedView3D * >::iterator SynchronizedView3DIt;
57  QGoSynchronizedView2D * tempComp;
58  QGoSynchronizedView3D * tempComp3D;
59 
60  // first we delete the synchronizer if any
61  if ( m_Synchronizer != NULL ) { delete ( m_Synchronizer ); }
62  if ( m_Synchronizer3D != NULL ) { delete ( m_Synchronizer3D ); }
63 
64  // and the we delete the SynchronizedViews2D
65  SynchronizedViewIt = m_openSynchronizedViews.begin();
66  while ( !m_openSynchronizedViews.empty() )
67  {
68  // delete all pointers in the vector
69  tempComp = *SynchronizedViewIt;
70  m_openSynchronizedViews.erase(SynchronizedViewIt);
71  delete ( tempComp );
72  }
73 
74  // and the we delete the SynchronizedViews3D
75  SynchronizedView3DIt = m_openSynchronizedViews3D.begin();
76  while ( !m_openSynchronizedViews3D.empty() )
77  {
78  // delete all pointers in the vector
79  tempComp3D = *SynchronizedView3DIt;
80  m_openSynchronizedViews3D.erase(SynchronizedView3DIt);
81  delete ( tempComp3D );
82  }
83 }
84 
85 //--------------------------------------------------------------------------
88  QString iSynchronizedViewName,
89  vtkImageData *iImage)
90 {
91  if ( iImage == NULL )
92  {
93  return NULL;
94  }
95 
96  int dim[3];
97  iImage->GetDimensions(dim);
98 
99  if ( ( dim[0] != 1 ) && ( dim[1] != 1 ) && ( dim[2] != 1 ) )
100  {
101  return static_cast< QGoSynchronizedView * >(
102  newSynchronizedView3D(iSynchronizedViewName, iImage) );
103  }
104  else
105  {
106  return static_cast< QGoSynchronizedView * >(
107  newSynchronizedView2D(iSynchronizedViewName, iImage) );
108  }
109 }
110 
111 //--------------------------------------------------------------------------
112 // add a SynchronizedView to QGoSynchronizedViewManager's parent Object/Widget
114 QGoSynchronizedViewManager::newSynchronizedView2D(QString iSynchronizedViewName, vtkImageData *iImage)
115 {
116  if ( ( iSynchronizedViewName.isEmpty() ) || ( iImage == NULL ) )
117  {
118  return NULL;
119  }
120  // we create a new SynchronizedView with the same parent windows as this
121  QGoSynchronizedView2D *nSynchronizedView =
122  new QGoSynchronizedView2D( iSynchronizedViewName,
123  static_cast< QWidget * >( this->parent() ) );
124 
125  // we add the vtkimage to it
126  nSynchronizedView->SetImage(iImage);
127 
128  // we add the SynchronizedView to the list of open SynchronizedViews
129  m_openSynchronizedViews.push_back(nSynchronizedView);
130 
131  // if we are synchronizing different SynchronizedViews
132  if ( m_Synchronizer != NULL )
133  {
134  // we tell the synchronizer to also synchronize the new SynchronizedView
135  m_Synchronizer->addSynchronizedView(nSynchronizedView);
136  }
137 
138  // tell the SynchronizedView who is his Manager
139  nSynchronizedView->SetViewManager(this);
140 
141  return nSynchronizedView;
142 }
143 
144 //--------------------------------------------------------------------------
145 
146 //--------------------------------------------------------------------------
147 // add a SynchronizedView to QGoSynchronizedViewManager's parent Object/Widget
149 QGoSynchronizedViewManager::newSynchronizedView3D(QString iSynchronizedViewName, vtkImageData *iImage)
150 {
151  if ( ( iSynchronizedViewName.isEmpty() ) || ( iImage == NULL ) )
152  {
153  return NULL;
154  }
155  // we create a new SynchronizedView with the same parent windows as this
156  QGoSynchronizedView3D *nSynchronizedView =
157  new QGoSynchronizedView3D( iSynchronizedViewName,
158  static_cast< QWidget * >( this->parent() ) );
159 
160  // we add the vtkimage to it
161  nSynchronizedView->SetImage(iImage);
162 
163  // we add the SynchronizedView to the list of open SynchronizedViews
164  m_openSynchronizedViews3D.push_back(nSynchronizedView);
165 
166  // if we are synchronizing different SynchronizedViews
167  if ( m_Synchronizer3D != NULL )
168  {
169  // we tell the synchronizer to also synchronize the new SynchronizedView
170  m_Synchronizer3D->addSynchronizedView(nSynchronizedView);
171  }
172 
173  // tell the SynchronizedView who is his Manager
174  nSynchronizedView->SetViewManager(this);
175 
176  return nSynchronizedView;
177 }
178 
179 //--------------------------------------------------------------------------
180 
181 //--------------------------------------------------------------------------
182 // delete a SynchronizedView from QGoSynchronizedViewManager's parent
183 // Object/Widget
184 void
186 {
187  std::vector< QGoSynchronizedView2D * >::iterator SynchronizedViewIt;
188 
189  if ( ioSynchronizedView == NULL ) { return; }
190 
191  // We look for the SynchronizedView in the vector of synchronized
192  // SynchronizedViews
193  SynchronizedViewIt = std::find(m_openSynchronizedViews.begin(), m_openSynchronizedViews.end(),
194  ioSynchronizedView);
195 
196  if ( SynchronizedViewIt == m_openSynchronizedViews.end() ) { return; }
197 
198  // if we are synchronizing different SynchronizedViews
199  if ( m_Synchronizer != NULL )
200  {
201  // we tell the synchronizer to remove the SynchronizedView
202  m_Synchronizer->removeSynchronizedView(ioSynchronizedView);
203  }
204 
205  ioSynchronizedView->close();
206 
207  delete ioSynchronizedView;
208 
209  // we remove the SynchronizedView to the list of open SynchronizedViews
210  m_openSynchronizedViews.erase(SynchronizedViewIt);
211 }
212 
213 //--------------------------------------------------------------------------
214 //--------------------------------------------------------------------------
215 // delete a SynchronizedView from QGoSynchronizedViewManager's parent
216 // Object/Widget
217 void
219 {
220  QGoSynchronizedView2D *tempComp;
221 
222  // if there is a problem acessing the SynchronizedView
223  if ( m_openSynchronizedViews.at(iIndex) == NULL ) { return; }
224 
225  tempComp = m_openSynchronizedViews.at(iIndex);
226  // if we are synchronizing different SynchronizedViews
227  if ( m_Synchronizer != NULL )
228  {
229  // we tell the synchronizer to remove the SynchronizedView
231  }
232 
233  tempComp->close();
234 
235  delete tempComp;
236 
237  // we remove the SynchronizedView to the list of open SynchronizedViews
238  m_openSynchronizedViews.erase(m_openSynchronizedViews.begin() + iIndex);
239 }
240 
241 //--------------------------------------------------------------------------
242 //--------------------------------------------------------------------------
243 // take a SynchronizedView out of the Manager lists, without deleting it.
244 void
246 {
247  if ( ioSynchronizedView == NULL ) { return; }
248 
249  std::vector< QGoSynchronizedView2D * >::iterator SynchronizedViewIt;
250 
251  // We look for the SynchronizedView in the vector of synchronized
252  // SynchronizedViews
253  SynchronizedViewIt = std::find(m_openSynchronizedViews.begin(), m_openSynchronizedViews.end(),
254  ioSynchronizedView);
255  // if we don't find it
256  if ( SynchronizedViewIt == m_openSynchronizedViews.end() ) { return; }
257 
258  // if we are synchronizing SynchronizedViews
259  if ( m_Synchronizer != NULL ) // we tell the synchronizer to remove the
260  // SynchronizedView
261  {
262  m_Synchronizer->removeSynchronizedView(ioSynchronizedView);
263  }
264 
265  ioSynchronizedView->close();
266 
267  // we remove the SynchronizedView to the list of open SynchronizedViews
268  m_openSynchronizedViews.erase(SynchronizedViewIt);
269 }
270 
271 //--------------------------------------------------------------------------
272 
273 //--------------------------------------------------------------------------
274 // delete a SynchronizedView from QGoSynchronizedViewManager's parent
275 // Object/Widget
276 void
278 {
279  std::vector< QGoSynchronizedView3D * >::iterator SynchronizedView3DIt;
280 
281  if ( ioSynchronizedView == NULL ) { return; }
282 
283  // We look for the SynchronizedView in the vector of synchronized
284  // SynchronizedViews
285  SynchronizedView3DIt = std::find(m_openSynchronizedViews3D.begin(), m_openSynchronizedViews3D.end(),
286  ioSynchronizedView);
287  // if we don't find it
288  if ( SynchronizedView3DIt == m_openSynchronizedViews3D.end() ) { return; }
289 
290  // if we are synchronizing SynchronizedViews
291  if ( m_Synchronizer3D != NULL )
292  {
293  // we tell the synchronizer to remove the SynchronizedView
294  m_Synchronizer3D->removeSynchronizedView(ioSynchronizedView);
295  }
296 
297  ioSynchronizedView->close();
298 
299  delete ioSynchronizedView;
300 
301  // we remove the SynchronizedView fromo the list of open SynchronizedViews
302  m_openSynchronizedViews3D.erase(SynchronizedView3DIt);
303 }
304 
305 //--------------------------------------------------------------------------
306 //--------------------------------------------------------------------------
307 // delete a SynchronizedView from QGoSynchronizedViewManager's parent
308 // Object/Widget
309 void
311 {
312  QGoSynchronizedView3D *tempComp3D;
313 
314  // if there is a problem acessing the SynchronizedView
315  if ( m_openSynchronizedViews3D.at(iIndex) == NULL ) { return; }
316 
317  tempComp3D = m_openSynchronizedViews3D.at(iIndex);
318 
319  // if we are synchronizing different SynchronizedViews
320  if ( m_Synchronizer3D != NULL )
321  {
322  // we tell the synchronizer to remove the SynchronizedView
324  }
325 
326  tempComp3D->close();
327 
328  delete tempComp3D;
329 
330  // we remove the SynchronizedView to the list of open SynchronizedViews
332 }
333 
334 //--------------------------------------------------------------------------
335 //--------------------------------------------------------------------------
336 // take a SynchronizedView out of the Manager lists, without deleting it.
337 void
339 {
340  if ( ioSynchronizedView == NULL ) { return; }
341 
342  std::vector< QGoSynchronizedView3D * >::iterator SynchronizedView3DIt;
343 
344  // We look for the SynchronizedView in the vector of synchronized
345  // SynchronizedViews
346  SynchronizedView3DIt = std::find(m_openSynchronizedViews3D.begin(), m_openSynchronizedViews3D.end(),
347  ioSynchronizedView);
348  // if we don't find it
349  if ( SynchronizedView3DIt == m_openSynchronizedViews3D.end() ) { return; }
350 
351  // if we are synchronizing different SynchronizedViews
352  if ( m_Synchronizer3D != NULL )
353  {
354  // we tell the synchronizer to remove the SynchronizedView
355  m_Synchronizer3D->removeSynchronizedView(ioSynchronizedView);
356  }
357 
358  ioSynchronizedView->close();
359 
360  // we remove the SynchronizedView to the list of open SynchronizedViews
361  m_openSynchronizedViews3D.erase(SynchronizedView3DIt);
362 }
363 
364 //--------------------------------------------------------------------------
365 
366 //--------------------------------------------------------------------------
367 // remove the synchronizer leaving the SynchronizedViews independent
368 void
370 {
371  if ( m_Synchronizer != NULL ) { delete ( m_Synchronizer ); }
372 
373  if ( m_Synchronizer3D != NULL ) { delete ( m_Synchronizer3D ); }
374 
375  m_Synchronizer = NULL;
376  m_Synchronizer3D = NULL;
377 }
378 
379 //--------------------------------------------------------------------------
380 
381 //--------------------------------------------------------------------------
382 // synchronize all open SynchronizedViews
383 void
385 {
386  if ( m_Synchronizer == NULL )
387  {
390  }
391 
393 }
394 
395 //--------------------------------------------------------------------------
396 
397 //--------------------------------------------------------------------------
398 // true if the orchestra synchronizes copmarers
399 bool
401 {
402  if ( ( m_Synchronizer != NULL ) || ( m_Synchronizer3D != NULL ) ) { return true; }
403  else
404  {
405  return false;
406  }
407 }
408 
409 //--------------------------------------------------------------------------
410 
411 //--------------------------------------------------------------------------
412 // synchronize all open SynchronizedViews
413 void
415 {
416  std::vector< QGoSynchronizedView2D * >::iterator SynchronizedViewIt;
417 
418  // we update all SynchronizedViews
419  for ( SynchronizedViewIt = m_openSynchronizedViews.begin();
420  SynchronizedViewIt != m_openSynchronizedViews.end();
421  ++SynchronizedViewIt )
422  {
423  ( *SynchronizedViewIt )->Update();
424  }
425 
426  std::vector< QGoSynchronizedView3D * >::iterator SynchronizedView3DIt;
427 
428  // we update all SynchronizedViews
429  for ( SynchronizedView3DIt = m_openSynchronizedViews3D.begin();
430  SynchronizedView3DIt != m_openSynchronizedViews3D.end();
431  ++SynchronizedView3DIt )
432  {
433  ( *SynchronizedView3DIt )->Update();
434  }
435 }
436 
437 //--------------------------------------------------------------------------
438 
439 //--------------------------------------------------------------------------
440 //show all the SynchronizedViews
441 void
443 {
444  std::vector< QGoSynchronizedView2D * >::iterator SynchronizedViewIt;
445 
446  // we update all SynchronizedViews
447  for ( SynchronizedViewIt = m_openSynchronizedViews.begin();
448  SynchronizedViewIt != m_openSynchronizedViews.end();
449  ++SynchronizedViewIt )
450  {
451  ( *SynchronizedViewIt )->show();
452  }
453 
454  std::vector< QGoSynchronizedView3D * >::iterator SynchronizedView3DIt;
455 
456  // we update all SynchronizedViews
457  for ( SynchronizedView3DIt = m_openSynchronizedViews3D.begin();
458  SynchronizedView3DIt != m_openSynchronizedViews3D.end();
459  ++SynchronizedView3DIt )
460  {
461  ( *SynchronizedView3DIt )->show();
462  }
463 }
464 
465 //--------------------------------------------------------------------------
bool close()
abstract class for QGoSynchronizedView2D and QGoSynchronizedView3D. Those classes are used to display...
QGoSynchronizedView3DCallbacks * m_Synchronizer3D
class used to display a QWidget containing a two dimensional a vtkimagedata* or an itkimage*...
void SetImage(vtkImageData *iImage)
This object takes a list of QGoSynchronizedView and synchronize their cameras by setting up callbacks...
bool isSynchronizing()
true if the manager synchronizes some QGoSynchronizedView
void show()
show all the QGoSynchronizedView s
void removeSynchronizedView3D(QGoSynchronizedView3D *ioSynchronizedView)
void Update()
update the QGoSynchronizedView s
void removeSynchronizedView(QGoSynchronizedView3D *ioSynchronizedView)
remove a QGoSynchronizedView3D from the vector of synchronized Managers (this method takes care of re...
void removeSynchronizedView(QGoSynchronizedView2D *ioSynchronizedView)
remove a SynchronizedView from the vector of synchronized SynchronizedViews (this method takes care o...
void synchronizeOpenSynchronizedViews()
synchronize all open QGoSynchronizedViews
void SetViewManager(QGoSynchronizedViewManager *iViewManager)
Set the address of the QGoSynchronizedViewManager.
bool isEmpty() const
QGoSynchronizedView2DCallbacks * m_Synchronizer
void deleteSynchronizedView3D(QGoSynchronizedView3D *ioSynchronizedView)
QGoSynchronizedView3D * newSynchronizedView3D(QString iSynchronizedViewName, vtkImageData *iImage)
create and add a QGoSynchronizedView3D to QGoSynchronizedViewManager&#39;s parent Object/Widget ...
class used to display a QWidget containing a two dimensional vtkimagedata* or itkimage*. QGoSynchronizedView3D provide the interface to synchronize cameras among several GoSynchronizedView3D.
std::vector< QGoSynchronizedView3D * > m_openSynchronizedViews3D
This object takes a list of QGoSynchronizedView and synchronize their cameras by setting up callbacks...
void addSynchronizedView(QGoSynchronizedView3D *ioSynchronizedView)
add a QGoSynchronizedView3D to the vector of synchronized Managers (this method takes care of adding ...
QGoSynchronizedView2D * newSynchronizedView2D(QString iSynchronizedViewName, vtkImageData *iImage)
create and add a QGoSynchronizedView2D to QGoSynchronizedViewManager&#39;s parent Object/Widget ...
void deleteSynchronizedView2D(QGoSynchronizedView2D *ioSynchronizedView)
delete a QGoSynchronizedView from QGoSynchronizedViewManager&#39;s parent Object/Widget delete the QGoSyn...
std::vector< QGoSynchronizedView2D * > m_openSynchronizedViews
void SetImage(vtkImageData *iImage)
Set image displayed by the SynchronizedView.
QObject * parent() const
void unSynchronizeOpenSynchronizedViews()
remove the synchronization leaving the all QGoSynchronizedView independent
void removeSynchronizedView2D(QGoSynchronizedView2D *ioSynchronizedView)
take a QGoSynchronizedView out of the Manager lists, without deleting it.
QGoSynchronizedView3D * newSynchronizedView(QString iSynchronizedViewName, typename itk::Image< TPixel, 3 >::Pointer iImage)
create and add a QGoSynchronizedView to QGoSynchronizedViewManager&#39;s parent Object/Widget ...
void addSynchronizedView(QGoSynchronizedView2D *ioSynchronizedView)
add a SynchronizedView to the vector of synchronized SynchronizedViews (this method takes care of add...