QGoPrintDatabase.h

Go to the documentation of this file.

/*=========================================================================
 Authors: The GoFigure Dev. Team.
 at Megason Lab, Systems biology, Harvard Medical school, 2009-11

 Copyright (c) 2009-11, President and Fellows of Harvard College.
 All rights reserved.

 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:

 Redistributions of source code must retain the above copyright notice,
 this list of conditions and the following disclaimer.
 Redistributions in binary form must reproduce the above copyright notice,
 this list of conditions and the following disclaimer in the documentation
 and/or other materials provided with the distribution.
 Neither the name of the  President and Fellows of Harvard College
 nor the names of its contributors may be used to endorse or promote
 products derived from this software without specific prior written
 permission.

 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
 BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
 OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
 OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

=========================================================================*/
#ifndef __QGoPrintDatabase_h
#define __QGoPrintDatabase_h

#include <QDockWidget>
#include <QTableWidget>
#include <QColor>
#include <string>
#include <QStackedWidget>
#include "MegaVTK2Configure.h"
#include "GoDBRecordSet.h"
#include "GoDBContourRow.h"
#include "vtkMySQLDatabase.h"
#include "vtkPolyData.h"
#include "GoDBTraceInfoForVisu.h"
#include "ContourMeshStructure.h"
#include "TraceInfoStructure.h"
#include "QGoDBBookmarkManager.h"
#include "QGoGUILibConfigure.h"
#include "GoFigureMeshAttributes.h"
#include "QGoTraceSettingsWidget.h"
#include "QGoDBCellTypeManager.h"
#include "QGoDBSubCellTypeManager.h"
#include "QGoDBColorManager.h"
#include "QGoDBMeshManager.h"
#include "QGoDBContourManager.h"
#include "QGoDBTrackManager.h"
#include "QGoDBLineageManager.h"
#include "ContourContainer.h"
#include "MeshContainer.h"
#include "TrackContainer.h"
#include "QGoDockWidget.h"
class QGOGUILIB_EXPORT QGoPrintDatabase:public QGoDockWidget
{
  Q_OBJECT
public:

  explicit QGoPrintDatabase(QWidget *iParent = 0);

  virtual ~QGoPrintDatabase();

  typedef GoDBCollectionOfTraces::TWContainerType            TWContainerType;
  typedef QGoDBBookmarkManager::NamesDescrContainerType      NamesDescrContainerType;
  typedef QGoTraceSettingsWidget::ItemColorComboboxData  ItemColorComboboxData;
  typedef std::pair< int, QColor >                           IDWithColorData;

  void SetDatabaseVariables(
    const std::string & iNameDB, const std::string & iServer,
    const std::string & iUser, const std::string & iPassword,
    const unsigned int & iImgSessionID, const std::string & iImgSessionName);

  void FillTableFromDatabase( const unsigned int& iTreshold);

  std::vector< ContourMeshStructure > GetContoursForAGivenTimepoint(
    unsigned int iTimePoint);

  std::vector< ContourMeshStructure > GetMeshesForAGivenTimepoint(
    unsigned int iTimePoint);

  void SaveContoursFromVisuInDB(unsigned int iXCoordMin,
                                unsigned int iYCoordMin, unsigned int iZCoordMin, unsigned int iTCoord,
                                unsigned int iXCoordMax, unsigned int iYCoordMax, unsigned int iZCoordMax,
                                vtkPolyData *iContourNodes);

  void SaveMeshFromVisuInDB(unsigned int iXCoordMin,
                            unsigned int iYCoordMin,
                            unsigned int iZCoordMin,
                            unsigned int iXCoordMax,
                            unsigned int iYCoordMax,
                            unsigned int iZCoordMax,
                            int iTCoord,
                            vtkPolyData *iMeshNodes,
                            GoFigureMeshAttributes *iMeshAttributes,
                            int iTrackID = -1);

  unsigned int SaveNewContourForMeshToContours(unsigned int iXCoordMin,
                                               unsigned int iYCoordMin,
                                               unsigned int iZCoordMin,
                                               unsigned int iXCoordMax,
                                               unsigned int iYCoordMax,
                                               unsigned int iZCoordMax,
                                               vtkPolyData *iTraceNodes);

  void AddBookmark(int iXCoord, int iYCoord,
                   int iZCoord, int iTCoord);

  std::string InWhichTableAreWe();

  NamesDescrContainerType GetListBookmarks();

  GoDBCoordinateRow GetCoordinateForBookmark(std::string iName);

  bool IsDatabaseUsed();

  //QAction * toggleViewAction();

  void ImportContours();

  void ImportMeshes();

  std::vector<int> ImportTracks();

  void PrintVolumeAreaForMesh(GoFigureMeshAttributes *
                              iMeshAttributes, unsigned int iMeshID);

  void PrintCalculatedValuesForTrack(GoFigureTrackAttributes *
                        iTrackAttributes, unsigned int iTrackID);

  QGoTraceSettingsWidget*  GetTraceSettingsWidget();

  QGoTraceSettingsWidget*  GetTraceSettingsWidgetForToolBar();

  void SetTraceNameForTableWidget(std::string iTraceName);

  void InitializeTheComboboxesNotTraceRelated();

  void SetContoursContainer(ContourContainer *iContoursContainer);

  void SetMeshesContainer(MeshContainer *iMeshesContainer);

  void SetTracksContainer(TrackContainer *iContainer);

  void SetLineagesContainers(LineageContainer *iContainer,
    TrackContainer *iTrackContainer);

  bool NeedTraceSettingsToolBarVisible();

  std::list<unsigned int> UpdateTableWidgetAndContainersForGivenTimePoint(
          const unsigned int& iNewTimePoint);

  std::list<unsigned int> GetVisibleTimePoints();

  int GetNumberOfElementForTraceAndTimePoint(std::string iTrace, int iTimePoint);

public slots:
  void DeleteBookmarks();

  //void SetTable(std::string iTablename);

  void ExportContours();

  void ExportMeshes();

  void UpdateSelectedTimePoint(int iTimePoint);

  void SaveNewMeshForMeshToContours(int iNumberOfContours);

signals:
  void PrintDBReady();

  void DBVariablesSet();

  void TraceToReEdit(unsigned int);

  void OpenBookmarksToUpdate();

  void NewMeshToGenerate(std::list< unsigned int > ListContourIDs, int iNewMeshID);

  void NeedToGoToTheLocation(int XCoord, int YCoord, int ZCoord, int TCoord);

  void NeedToGoToTheRealLocation(double XCoord, double YCoord, double ZCoord, int TCoord);

  void PrintMessage(QString iMessage, int iTimeOut = 0);

protected:
  //related to 3dwt:
  int*                  m_SelectedTimePoint;
  QGoDBBookmarkManager* m_BookmarkManager;

  //related to TraceSettings Widget:
  QGoDBCellTypeManager*             m_CellTypeManager;
  QGoDBSubCellTypeManager*          m_SubCellTypeManager;
  QGoDBColorManager*                m_ColorManager;
  QGoTraceSettingsWidget*           m_TraceSettingsWidget;
  QGoTraceSettingsWidget*           m_TraceSettingsWidgetForToolBar;

  QGoDBContourManager*              m_ContoursManager;
  QGoDBMeshManager*                 m_MeshesManager;
  QGoDBTrackManager*                m_TracksManager;
  QGoDBLineageManager*              m_LineagesManager;
  QStackedWidget*                   m_StackedTables;

  //Database variables:
  vtkMySQLDatabase* m_DatabaseConnector;
  std::string       m_Server;
  std::string       m_User;
  std::string       m_Password;
  std::string       m_DBName;
  unsigned int      m_ImgSessionID;
  std::string       m_ImgSessionName;
  bool              m_IsDatabaseUsed;

  bool m_ReeditMode;
  bool m_MeshGenerationMode;
  bool m_TraceSettingsVisible;

  void OpenDBConnection();

  void SetUpUi();

  void SetConnectionsBetweenTheInstancesOfTraceSettings();
  void SetContoursManager();

  void SetMeshesManager();

  void SetTracksManager();

  void SetLineagesManager();

  //******************Methods related to Trace Settings Editing Widget***********

  void CreateConnectionsForTraceSettingsWidget(QGoTraceSettingsWidget* iTraceSettingsWidget);

  void SetTSListCellTypes(std::string iCellTypeToSelect = "");

  void SetTSListCellTypesWithPreviousSelectedOne();

  void SetTSListSubCellTypes(std::string iSubCellTypeToSelect = "");

  void SetTSListSubCellTypesWithPreviousSelectedOne();

  void SetTSListColors(std::string iColorToSelect = "");

  void SetTSListColorsWithPreviousSelectedOne();

  //******************End of Methods related to Trace Settings Editing
  // Widget***********

  std::list< ItemColorComboboxData > GetListCollectionIDFromDB(
    vtkMySQLDatabase *iDatabaseConnector, std::string & ioIDToSelect);

  //void closeEvent(QCloseEvent *event);

  void SetTracesManager();

  void GetContentAndDisplayAllTracesInfo(vtkMySQLDatabase *iDatabaseConnector);

  void GetContentAndDisplayAllTracesInfoFor3TPs(vtkMySQLDatabase *iDatabaseConnector);

  void RemoveTracesFromListTimePoints(
  vtkMySQLDatabase *iDatabaseConnector, std::list<unsigned int> iListTimePoints);

  /*template< typename T >
  QColor GetQColorFromTraceRow(T iTraceRow, vtkMySQLDatabase *iDatabaseConnector)
  {
    GoDBColorRow ColorRow;

    ColorRow.SetValuesForSpecificID(iTraceRow.GetMapValue<int>("ColorID"),
                                    iDatabaseConnector);
    QColor Color( ColorRow.GetMapValue<int>("Red"),
                  ColorRow.GetMapValue<int>("Green"),
                  ColorRow.GetMapValue<int>("Blue"),
                  ColorRow.GetMapValue<int>("Alpha") );
    return Color;
  }
*/
  template< typename T >
  void SetTheColorForTheRow(T & ioRow, QColor iColor)
  {
    ioRow.SetField( "Red", iColor.red() );
    ioRow.SetField( "Green", iColor.green() );
    ioRow.SetField( "Blue", iColor.blue() );
    ioRow.SetField( "Alpha", iColor.alpha() );
  }

  template< typename TTrace, typename TCollection >
  void ChangeTraceColor(TTrace *iTraceManager,
                        TCollection *iCollectionOfManager)
  {
    this->OpenDBConnection();
    //update everything for the traces and get the list of collection ID they
    //are collection of:
    std::list< unsigned int > ListCollectionOfIDsToUpdate =
      iTraceManager->UpdateTheTracesColor(this->m_DatabaseConnector);//, *this->m_SelectedColorData);
    iCollectionOfManager->DisplayInfoForExistingTraces(this->m_DatabaseConnector,
                                                       ListCollectionOfIDsToUpdate);
    this->CloseDBConnection();
  }

  template< typename TTrace, typename TCollection, typename TCollectionOf >
  void DeleteCheckedTraces(TTrace *iTraceManager,
                    TCollection *iCollectionManager, TCollectionOf *iCollectionOfManager,
                    bool lineage = false)
                    //bool track = false)
  {
    std::list< unsigned int > ListTracesToDelete =
      iTraceManager->GetListHighlightedIDs();
    std::list<unsigned int> ListCollectionsIDs =
      this->UpdateCollectionDataForTracesToBeDeleted<TTrace, TCollectionOf>
      (iTraceManager, iCollectionOfManager, ListTracesToDelete);
    this->OpenDBConnection();
    iTraceManager->DeleteCheckedTraces(this->m_DatabaseConnector);

    if ( !ListCollectionsIDs.empty() || !lineage )
      {
      this->OpenDBConnection(); //in some cases the DeleteCheckedTraces closes the connection
      iCollectionManager->UpdateBoundingBoxes(this->m_DatabaseConnector, ListCollectionsIDs);
      }
    this->CloseDBConnection();
  }

  template< typename TTrace, typename TCollection, typename TCollectionOf >
  void DeleteListTraces(TTrace *iTraceManager,
                    TCollection *iCollectionManager, TCollectionOf *iCollectionOfManager,
                    std::list<unsigned int> iListTracesToDelete,
                    bool lineage = false)
  {
    std::list<unsigned int> ListCollectionsIDs =
      this->UpdateCollectionDataForTracesToBeDeleted<TTrace, TCollectionOf>
      (iTraceManager, iCollectionOfManager, iListTracesToDelete);
    this->OpenDBConnection();
    iTraceManager->DeleteListTraces(this->m_DatabaseConnector, iListTracesToDelete);

    if ( !ListCollectionsIDs.empty() || !lineage )
      {
      iCollectionManager->UpdateBoundingBoxes(this->m_DatabaseConnector, ListCollectionsIDs);
      }
    this->CloseDBConnection();
  }
  template< typename TTrace, typename TCollectionOf >
  std::list<unsigned int> UpdateCollectionDataForTracesToBeDeleted(TTrace *iTraceManager,
                        TCollectionOf *iCollectionOfManager,
                        std::list<unsigned int> iListTracesToDelete)
  {
    this->OpenDBConnection();
    //need to get all the needed data from the traces before deleting them:
    std::list< unsigned int > ListCollectionsIDs =
      iTraceManager->GetListCollectionIDs(this->m_DatabaseConnector, iListTracesToDelete);
    std::list< unsigned int > ListTracesAsCollectionOf =
      iTraceManager->GetListTracesIDsFromThisCollectionOf(this->m_DatabaseConnector,
                                                          iListTracesToDelete);
    if ( !ListTracesAsCollectionOf.empty() )
      {
      iCollectionOfManager->UpdateCollectionID(this->m_DatabaseConnector,
                                               ListTracesAsCollectionOf, 0);
      }
    this->CloseDBConnection();
    return ListCollectionsIDs;
  }
  template< typename TTrace, typename TCollection >
  void AddCheckedTracesToCollection(
    TTrace *iTraceManager,
    TCollection *iCollectionManager, unsigned int iCollectionID,
    std::list< unsigned int > iListCheckedTraces)
  {
    this->OpenDBConnection();
    //get the list of CollectionIDs that will be updated:
    std::list< unsigned int > ListCollectionIDsToUpdate =
      iTraceManager->GetListCollectionIDs(this->m_DatabaseConnector,
                                          iListCheckedTraces);

    iTraceManager->UpdateCollectionID(this->m_DatabaseConnector,
                                      iListCheckedTraces, iCollectionID);

    if (iCollectionID != 0)
      {
      ListCollectionIDsToUpdate.push_back(iCollectionID);
      }
    iCollectionManager->UpdateBoundingBoxes(this->m_DatabaseConnector,
                                            ListCollectionIDsToUpdate);
  this->CloseDBConnection();
  }

  void UpdateSelectedCollectionForTableWidget(std::string iTableName);

//-------------------------------------------------------------------------

//-------------------------------------------------------------------------
protected slots:
  void CreateContextMenu(const QPoint & iPos);

  void ShowHideTraceSettingsFromContextMenu(bool isVisible);

  void TheTraceHasChanged(int iIndex);

  void SetTSListCollectionID();

  void PassDBConnectionToContoursManager();

  void PassDBConnectionToMeshesManager();

  void PassDBConnectionToTracksManager();

  void PassDBConnectionToLineagesManager();

  void CloseDBConnection();
  void ChangeMeshColor();

  void ChangeTrackColor();

  void ChangeLineageColor();

  void DeleteCheckedContours();

  void DeleteCheckedMeshes();

  void DeleteCheckedTracks();

  void DeleteCheckedLineages();

  void CreateNewTrackFromListMeshes(std::list< unsigned int > iListMeshes);

  void CreateNewTrackFromListMeshes(
    std::list<std::list<unsigned int> > iListsCheckedMeshes);

  void CreateNewMeshFromCheckedContours(std::list< unsigned int > iListCheckedContours);

  void CreateNewLineageFromTracks(std::list< unsigned int > iListCheckedTracks,
    unsigned int iTrackIDRoot, std::list<unsigned int> iLineagesToDelete);

  void AddCheckedContoursToSelectedMesh(std::list< unsigned int > iListCheckedContours);

  void AddCheckedMeshesToSelectedTrack(std::list< unsigned int > iListCheckedMeshes);

  void AddCheckedTracksToSelectedLineage(
    std::list<unsigned int> iListDaughters, unsigned int iLineageID,
    std::list<unsigned int> iListLineagesToDelete);

  void ReEditTrace(unsigned int iTraceID);

  void PassMeshesInfoForImportedTrack(unsigned int iTrackID);

  void SplitTheTrack(unsigned int iTrackID, std::list<unsigned int> iListMeshIDs);

  void SplitMergeTracksWithWidget(std::list<unsigned int> iTrackIDs);

  void AddListMeshesToATrack(std::list< unsigned int > iListMeshes, unsigned int iTrackID);

  void AddListMeshesToATrack(
    std::map<unsigned int, std::list<unsigned int> > iListMeshesWithTracks);

  //*********************Slots for
  // TraceManualEditingWidget:**************************
  void SaveNewCollectionFromTraceWidgetInDBAndTW();

  void AddNewCellType();

  void AddNewSubCellType();

  void AddNewColor();

  void DeleteCellType();

  void DeleteSubCellType();

  void DeleteColor();

  //**********************End TraceSettingsWidget slots // related****************
private:
  std::list<unsigned int> m_VisibleTimePoints;
  Q_DISABLE_COPY(QGoPrintDatabase);
};

#endif