GOFIGURE2  0.9.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
GoDBCollectionOfTraces.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 =========================================================================*/
34 #include "GoDBCollectionOfTraces.h"
36 #include "QueryDataBaseHelper.h"
37 #include "ConvertToStringHelper.h"
38 #include "vtkMySQLDatabase.h"
39 #include "GoDBCoordinateRow.h"
41 #include "GoDBMeshRow.h"
42 #include "GoDBTrackRow.h"
43 #include "GoDBLineageRow.h"
44 #include <QStringList>
45 #include <QString>
46 #include <string>
47 #include <map>
48 #include <algorithm>
49 
51 {
52 }
53 
54 //--------------------------------------------------------------------------
55 
56 //--------------------------------------------------------------------------
58  std::string iCollectionName, std::string iTracesName,
59  std::string iCollectionOfName, unsigned int iImgSessionID)
60 {
61  this->SetCollectionInfo(iCollectionName, iTracesName, iCollectionOfName);
62  this->SetImgSessionID(iImgSessionID);
63 }
64 
65 //--------------------------------------------------------------------------
66 
67 //--------------------------------------------------------------------------
69 {
70 }
71 
72 //--------------------------------------------------------------------------
73 
74 //--------------------------------------------------------------------------
75 void GoDBCollectionOfTraces::SetCollectionInfo(std::string iCollectionName,
76  std::string iTracesName,
77  std::string iCollectionOfName)
78 {
79  m_CollectionName = iCollectionName;
81  m_CollectionIDName += "ID";
82  m_TracesName = iTracesName;
84  m_TracesIDName += "ID";
85  m_CollectionOfName = iCollectionOfName;
87  m_CollectionOfIDName += "ID";
88 }
89 
90 //--------------------------------------------------------------------------
91 
92 //--------------------------------------------------------------------------
93 void GoDBCollectionOfTraces::SetImgSessionID(unsigned int iImgSessionID)
94 {
95  m_ImgSessionID = iImgSessionID;
96 }
97 
98 //--------------------------------------------------------------------------
99 
100 //--------------------------------------------------------------------------
101 //Modif into Database
102 void GoDBCollectionOfTraces::DeleteTracesInDB(std::list< unsigned int > TracesToDelete,
103  vtkMySQLDatabase *DatabaseConnector)
104 {
105  std::list< unsigned int >::iterator iter = TracesToDelete.begin();
106  while ( iter != TracesToDelete.end() )
107  {
108  unsigned int ID = *iter;
109 
110  // if the trace is a mesh, we should delete its intensity as well
111  if(m_TracesName.compare("mesh") == 0)
112  {
113  // delete the related intensity table
114  DeleteRow(DatabaseConnector, "intensity" , m_TracesIDName,
115  ConvertToString< unsigned int >(ID));
116  }
117 
118  DeleteRow( DatabaseConnector, m_TracesName, m_TracesIDName,
119  ConvertToString< unsigned int >(ID) );
120  ++iter;
121  }
122 }
123 
124 //--------------------------------------------------------------------------
125 
126 //--------------------------------------------------------------------------
127 //Modif into Database
129  vtkMySQLDatabase *DatabaseConnector)
130 {
131  DeleteRow( DatabaseConnector, m_TracesName, m_TracesIDName,
132  ConvertToString< int >(TraceToDelete) );
133 }
134 
135 //--------------------------------------------------------------------------
136 
137 //--------------------------------------------------------------------------
138 //Modif into Database
140  std::list< unsigned int > iListSelectedTraces, unsigned int inewCollectionID,
141  vtkMySQLDatabase *DatabaseConnector)
142 {
143  std::string newCollectionIDstring = ConvertToString< unsigned int >(inewCollectionID);
144 
145  std::list< unsigned int >::iterator iter = iListSelectedTraces.begin();
146  while ( iter != iListSelectedTraces.end() )
147  {
148  unsigned int TraceID = *iter;
149  UpdateValueInDB( DatabaseConnector, m_TracesName, m_CollectionIDName,
150  newCollectionIDstring, m_TracesIDName,
151  ConvertToString< unsigned int >(TraceID) );
152  ++iter;
153  }
154 }
155 
156 //--------------------------------------------------------------------------
157 
158 //--------------------------------------------------------------------------
159 //Modif into Database
161  int iSelectedTraceID, int inewCollectionID,
162  vtkMySQLDatabase *DatabaseConnector)
163 {
164  UpdateValueInDB( DatabaseConnector, m_TracesName, m_CollectionIDName,
165  ConvertToString< int >(inewCollectionID), m_TracesIDName,
166  ConvertToString< int >(iSelectedTraceID) );
167 }
168 
169 //--------------------------------------------------------------------------
170 
171 //--------------------------------------------------------------------------
173  vtkMySQLDatabase *iDatabaseConnector, std::string iNameValue,
174  std::string iValue, std::list< unsigned int > iListTraceIDs)
175 {
176  std::vector< unsigned int > VectIDs;
177  std::copy( iListTraceIDs.begin(), iListTraceIDs.end(), std::back_inserter(VectIDs) );
178  UpdateValueInDB(iDatabaseConnector, this->m_TracesName, iNameValue,
179  iValue, this->m_TracesIDName, VectIDs);
180 }
181 
182 //--------------------------------------------------------------------------
183 
184 //--------------------------------------------------------------------------
185 //Modif into Database
187  vtkMySQLDatabase *iDatabaseConnector, int iCollectionID)
188 {
189  //update the corresponding bounding box:
190  int CoordIDMax = this->GetCoordMaxID(iDatabaseConnector, iCollectionID);
191  int CoordIDMin = this->GetCoordMinID(iDatabaseConnector, iCollectionID);
192 
193  this->UpdateBoundingBoxInDB(CoordIDMin, CoordIDMax,
194  iCollectionID, iDatabaseConnector);
195 }
196 
197 //--------------------------------------------------------------------------
198 
199 //--------------------------------------------------------------------------
201  vtkMySQLDatabase *iDatabaseConnector, std::list< unsigned int > iListTracesIDs)
202 {
203  std::list< unsigned int >::iterator iter = iListTracesIDs.begin();
204  while ( iter != iListTracesIDs.end() )
205  {
206  this->RecalculateDBBoundingBox(iDatabaseConnector, *iter);
207  ++iter;
208  }
209 }
210 
211 //--------------------------------------------------------------------------
212 
213 //--------------------------------------------------------------------------
214 std::list< GoDBCollectionOfTraces::NameWithColorData >
216  vtkMySQLDatabase *iDatabaseConnector)
217 {
218  //First, build the query with selected fields and table to join with on
219  // conditions:
220  std::vector< std::string > SelectFields;
221  std::vector< std::string > JoinTablesOnTraceTable;
222  this->GetFieldsNeededForQueryForColorData(SelectFields, JoinTablesOnTraceTable);
223  std::vector< std::vector< std::string > > ResultsQuery;
224 
225  ResultsQuery = GetValuesFromSeveralTables(iDatabaseConnector,
226  this->m_TracesName, SelectFields,
227  "ImagingSessionID",
228  ConvertToString< unsigned int >(
229  this->m_ImgSessionID),
230  JoinTablesOnTraceTable, true);
231 
232  return this->GetListNameWithColorDataFromResultsQuery(ResultsQuery);
233 }
234 
235 //--------------------------------------------------------------------------
236 
237 //--------------------------------------------------------------------------
238 std::list< GoDBCollectionOfTraces::NameWithColorData >
240  vtkMySQLDatabase *iDatabaseConnector, unsigned int iTimePoint)
241 {
242  std::list< NameWithColorData > oListTraceIDs;
243  //First, build the query with selected fields and table to join with on
244  // conditions:
245  std::vector< std::string > SelectFields;
246  std::vector< std::string > JoinTablesOnTraceTable;
247  this->GetFieldsNeededForQueryForColorData(SelectFields, JoinTablesOnTraceTable);
248 
249  std::string JoinTable = "coordinate";
250  JoinTablesOnTraceTable.push_back(JoinTable);
251  std::string OnCondition = this->m_TracesName;
252  OnCondition += ".";
253  OnCondition += "CoordIDMin = coordinate.coordid";
254  JoinTablesOnTraceTable.push_back(OnCondition);
255  std::vector< std::string > WhereAndConditions;
256  OnCondition = this->m_TracesName;
257  OnCondition += ".ImagingsessionID";
258  WhereAndConditions.push_back(OnCondition);
259  WhereAndConditions.push_back( ConvertToString< unsigned int >(this->m_ImgSessionID) );
260  WhereAndConditions.push_back("coordinate.TCoord");
261  WhereAndConditions.push_back( ConvertToString< int >(iTimePoint) );
262 
263  std::vector< std::vector< std::string > > ResultsQuery = GetValuesFromSeveralTables(
264  iDatabaseConnector,
265  this->m_TracesName, SelectFields,
266  WhereAndConditions,
267  JoinTablesOnTraceTable, true);
268 
269  return this->GetListNameWithColorDataFromResultsQuery(ResultsQuery);
270 }
271 
272 //--------------------------------------------------------------------------
273 
274 //--------------------------------------------------------------------------
276  std::vector< std::string > & ioSelectedFields,
277  std::vector< std::string > & ioJoinTablesOnTraceTable)
278 {
279  ioSelectedFields.push_back(this->m_TracesIDName);
280  std::string Red = "color.Red";
281  ioSelectedFields.push_back(Red);
282  std::string Green = "color.Green";
283  ioSelectedFields.push_back(Green);
284  std::string Blue = "color.Blue";
285  ioSelectedFields.push_back(Blue);
286  std::string Alpha = "color.Alpha";
287  ioSelectedFields.push_back(Alpha);
288 
289  std::string JoinTable = "color";
290  ioJoinTablesOnTraceTable.push_back(JoinTable);
291  std::string OnCondition = this->m_TracesName;
292  OnCondition += ".ColorID = color.ColorID";
293  ioJoinTablesOnTraceTable.push_back(OnCondition);
294 }
295 
296 //--------------------------------------------------------------------------
297 
298 //--------------------------------------------------------------------------
299 std::list< GoDBCollectionOfTraces::NameWithColorData >
301  std::vector< std::vector< std::string > > iResultsQuery)
302 {
303  std::list< NameWithColorData > oListNameWithColorData;
304  unsigned int i = 0;
305  std::vector< std::vector< std::string > >::iterator iter = iResultsQuery.begin();
306  while ( iter != iResultsQuery.end() )
307  {
308  std::vector< std::string > ResultsOneRow = *iter;
309 
310  int intRed = atoi( ResultsOneRow[i + 1].c_str() );
311  int intGreen = atoi( ResultsOneRow[i + 2].c_str() );
312  int intBlue = atoi( ResultsOneRow[i + 3].c_str() );
313  int intAlpha = atoi( ResultsOneRow[i + 4].c_str() );
314 
315  QColor Color(intRed, intGreen, intBlue, intAlpha);
316  NameWithColorData temp;
317  temp.first = ResultsOneRow[i];
318  temp.second = Color;
319  oListNameWithColorData.push_back(temp);
320  ++iter;
321  }
322  return oListNameWithColorData;
323 }
324 
325 //--------------------------------------------------------------------------
326 
327 //--------------------------------------------------------------------------
328 //Get From Database
329 /*QStringList GoDBCollectionOfTraces::ListCollectionID(
330  vtkMySQLDatabase* DatabaseConnector)
331 {
332  QStringList ListIDs;
333  std::vector<std::string> vectListIDs = ListAllValuesForOneColumn(
334  DatabaseConnector, m_CollectionIDName, m_CollectionName);
335 
336  for (unsigned int i = 0; i < vectListIDs.size(); ++i)
337  {
338  ListIDs.append(vectListIDs[i].c_str());
339  }
340 
341  return ListIDs;
342 }*/
343 //--------------------------------------------------------------------------
344 
345 //--------------------------------------------------------------------------
346 //get from Database and/or Modif into Database
347 int GoDBCollectionOfTraces::GetCoordMinID(vtkMySQLDatabase *iDatabaseConnector,
348  int iTraceID)
349 {
350  //Get the list of the collectionof tracesID belonging to the iTraceID:
351  std::list< unsigned int > ListTracesIDs;
352  ListTracesIDs.push_back(iTraceID);
353  std::list< unsigned int > ListCollectionOfTraces =
354  this->GetListTracesIDsFromThisCollectionOf(iDatabaseConnector, ListTracesIDs);
355 
356  if ( ListCollectionOfTraces.empty() )
357  {
358  return this->GetCoordIDMinForBoundingBoxWithNoTraces(iDatabaseConnector);
359  }
360  else
361  {
362  //Get the min of the traces:
363  //std::vector< std::string > VectorCollectionOfTraces =
364  //ListUnsgIntToVectorString(ListCollectionOfTraces);
365  GoDBCoordinateRow TracesCoordMin = this->GetCollectionOfTracesCoordMin(
366  iDatabaseConnector, ListCollectionOfTraces);
367  return TracesCoordMin.SaveInDB(iDatabaseConnector);
368  }
369 }
370 
371 //--------------------------------------------------------------------------
372 
373 //--------------------------------------------------------------------------
374 //get from Database and/or Modif into Database
375 int GoDBCollectionOfTraces::GetCoordMaxID(vtkMySQLDatabase *iDatabaseConnector,
376  int iTraceID)
377 {
378  //Get the list of the tracesID belonging to the collection:
379  std::list< unsigned int > ListTracesIDs;
380  ListTracesIDs.push_back(iTraceID);
381  std::list< unsigned int > ListCollectionOfTraces =
382  this->GetListTracesIDsFromThisCollectionOf(iDatabaseConnector, ListTracesIDs);
383 
384  if ( ListCollectionOfTraces.empty() )
385  {
386  return this->GetCoordIDMaxForBoundingBoxWithNoTraces(iDatabaseConnector);
387  }
388  else
389  {
390  //Get the max of the traces:
391  //std::vector< std::string > VectorCollectionOfTraces =
392  // ListUnsgIntToVectorString(ListCollectionOfTraces);
393  GoDBCoordinateRow TracesCoordMax = this->GetCollectionOfTracesCoordMax(
394  iDatabaseConnector, ListCollectionOfTraces);
395  return TracesCoordMax.SaveInDB(iDatabaseConnector);
396  }
397 }
398 
399 //--------------------------------------------------------------------------
400 
401 //--------------------------------------------------------------------------
402 //get from Database and/or Modif into Database
404  vtkMySQLDatabase *DatabaseConnector,
405  std::list< unsigned int > iListCollectionOfTracesID)
406 {
407  GoDBCoordinateRow CoordMin;
408 
409  //First, get the coordID in the contour table that corresponds to the
410  //coordIDMin of the Contours selected:
411  std::list< unsigned int > ListCollectionOfTracesCoordIDMin =
412  ListSpecificValuesForOneColumn(DatabaseConnector,
413  this->m_CollectionOfName, "CoordIDMin", this->m_CollectionOfIDName,
414  iListCollectionOfTracesID);
415  //then, go to the coordinate table and compare the values for the coordID
416  //corresponding to the coordIDMax of the selected contours:
417  std::vector< std::string > ColumnNames = CoordMin.GetVectorColumnNames();
418  for ( unsigned int i = 0; i < ColumnNames.size(); i++ )
419  {
420  //don't compare the coordID !!!:
421  if ( ColumnNames[i] != "CoordID" )
422  {
423  std::vector< std::string > VectorCollectionOfTracesCoordIDMin = ListUnsgIntToVectorString(
424  ListCollectionOfTracesCoordIDMin);
425  CoordMin.SetField( ColumnNames[i], MinValueForOneColumnInTable(
426  DatabaseConnector, ColumnNames[i], "coordinate", "CoordID",
427  VectorCollectionOfTracesCoordIDMin) );
428  }
429  }
430  return CoordMin;
431 }
432 
433 //--------------------------------------------------------------------------
434 
435 //--------------------------------------------------------------------------
437  vtkMySQLDatabase *DatabaseConnector,
438  std::list< unsigned int > iListCollectionOfTracesID)
439 {
440  GoDBCoordinateRow CoordMax;
441 
442  //First, get the coordID in the contour table that corresponds to the
443  //coordIDMax of the Contours selected:
444  std::list< unsigned int > ListCollectionOfTracesCoordIDMax =
445  ListSpecificValuesForOneColumn(DatabaseConnector,
446  this->m_CollectionOfName, "CoordIDMax",
447  this->m_CollectionOfIDName,
448  iListCollectionOfTracesID);
449  //then, go to the coordinate table and compare the values for the coordID
450  //corresponding to the coordIDMax of the selected contours:
451  std::vector< std::string > ColumnNames = CoordMax.GetVectorColumnNames();
452  for ( unsigned int i = 0; i < ColumnNames.size(); i++ )
453  {
454  //don't compare the coordID !!!:
455  if ( ColumnNames[i] != "CoordID" )
456  {
457  std::vector< std::string > VectorCollectionOfTracesCoordIDMax = ListUnsgIntToVectorString(
458  ListCollectionOfTracesCoordIDMax);
459  CoordMax.SetField( ColumnNames[i], MaxValueForOneColumnInTable(
460  DatabaseConnector, ColumnNames[i], "coordinate", "CoordID",
461  VectorCollectionOfTracesCoordIDMax) );
462  }
463  }
464  return CoordMax;
465 }
466 
467 //--------------------------------------------------------------------------
468 
469 //--------------------------------------------------------------------------
470 /*int GoDBCollectionOfTraces::CreateCollectionWithNoTraces(
471  vtkMySQLDatabase* DatabaseConnector, GoDBTraceRow& iNewCollection,
472  int iTimePoint)
473 {
474  iNewCollection.SetField<unsigned int>("ImagingSessionID", this->m_ImgSessionID);
475 
476  int CoordIDMax = GetCoordIDMaxForBoundingBoxWithNoTraces(DatabaseConnector);
477  int CoordIDMin = GetCoordIDMinForBoundingBoxWithNoTraces(DatabaseConnector);
478 
479  iNewCollection.SetField<int>("CoordIDMax", CoordIDMax);
480  iNewCollection.SetField<int>("CoordIDMin", CoordIDMin);
481 
482  if (this->m_CollectionName == "mesh")
483  {
484  SetTheTimePointForMesh(iTimePoint, iNewCollection, DatabaseConnector);
485  }
486  return this->CreateNewCollection(DatabaseConnector, iNewCollection);
487 }*/
488 //--------------------------------------------------------------------------
489 
490 //--------------------------------------------------------------------------
492  vtkMySQLDatabase *iDatabaseConnector)
493 {
494  // As there is no traces in the collection, the bounding box is the minimum
495  // one:
496  // CoordIDMin correspond to the imagingsession Max:
497  return FindOneID( iDatabaseConnector, "imagingsession", "CoordIDMax",
498  "ImagingSessionID", ConvertToString< int >(this->m_ImgSessionID) );
499 }
500 
501 //--------------------------------------------------------------------------
502 
503 //--------------------------------------------------------------------------
505  vtkMySQLDatabase *iDatabaseConnector)
506 {
507  // As there is no traces in the collection, the bounding box is the minimum
508  // one:
509  // CoordIDMax correspond to the imagingsession Min:
510  return FindOneID( iDatabaseConnector, "imagingsession", "CoordIDMin",
511  "ImagingSessionID", ConvertToString< int >(this->m_ImgSessionID) );
512 }
513 
514 //--------------------------------------------------------------------------
515 
516 //--------------------------------------------------------------------------
518  unsigned int iTimePoint,
519  int & ioCoordIDMax,
520  int & ioCoordIDMin,
521  vtkMySQLDatabase *iDatabaseConnector)
522 {
523  GoDBCoordinateRow Coordinate;
524 
525  Coordinate.SetValuesForSpecificID(ioCoordIDMax, iDatabaseConnector);
526  Coordinate.SetField< int >("TCoord", iTimePoint);
527  Coordinate.SetField("CoordID", "0");
528  ioCoordIDMax = Coordinate.SaveInDB(iDatabaseConnector);
529 
530  Coordinate.SetValuesForSpecificID(ioCoordIDMin, iDatabaseConnector);
531  Coordinate.SetField< int >("TCoord", iTimePoint);
532  Coordinate.SetField("CoordID", "0");
533  ioCoordIDMin = Coordinate.SaveInDB(iDatabaseConnector);
534 }
535 
536 //--------------------------------------------------------------------------
537 
538 //--------------------------------------------------------------------------
540  vtkMySQLDatabase *DatabaseConnector, GoDBTraceRow & iNewCollection)
541 {
542  if ( this->m_CollectionName == "mesh" )
543  {
544  GoDBMeshRow NewMesh;
545  NewMesh.SafeDownCast(iNewCollection);
546 
547  return AddOnlyOneNewObjectInTable< GoDBMeshRow >(
548  DatabaseConnector, this->m_CollectionName, &NewMesh, m_CollectionIDName);
549  }
550  if ( this->m_CollectionName == "track" )
551  {
552  GoDBTrackRow *NewTrack = static_cast< GoDBTrackRow * >( &iNewCollection );
553  return AddOnlyOneNewObjectInTable< GoDBTrackRow >(
554  DatabaseConnector, this->m_CollectionName, NewTrack, m_CollectionIDName);
555  }
556  if ( this->m_CollectionName == "lineage" )
557  {
558  GoDBLineageRow *NewLineage = static_cast< GoDBLineageRow * >( &iNewCollection );
559  return AddOnlyOneNewObjectInTable< GoDBLineageRow >(
560  DatabaseConnector, this->m_CollectionName, NewLineage, m_CollectionIDName);
561  }
562  return 0;
563 }
564 
565 //--------------------------------------------------------------------------
566 
567 //--------------------------------------------------------------------------
568 /*std::list< unsigned int > GoDBCollectionOfTraces::UpdateDBDataForAddedTracesToExistingCollection(
569  std::list< unsigned int > iListSelectedTraces, int iNewCollectionID,
570  vtkMySQLDatabase *iDatabaseConnector)
571 {
572  std::list< unsigned int > ListTraceIDWithBoundingBoxUpdated;
573  std::vector< std::string > VectorSelectedTraces( iListSelectedTraces.size() );
574  std::list< unsigned int >::iterator iter = iListSelectedTraces.begin();
575  unsigned int i = 0;
576  while ( iter != iListSelectedTraces.end() )
577  {
578  unsigned int temp = *iter;
579  VectorSelectedTraces.at(i) = ConvertToString< unsigned int >(temp);
580  i++;
581  iter++;
582  }
583  //update the bounding boxes for the previous collection if the traces had one:
584  //std::list<int>::iterator iter = iListSelectedTraces.begin();
585 
586  std::vector< std::string > ListCollectionIDWithBoundingBoxToUpdate =
587  ListSpecificValuesForOneColumn(iDatabaseConnector, this->m_TracesName,
588  this->m_CollectionIDName, this->m_TracesIDName, VectorSelectedTraces, true, true);
589  //change the collectionID of the selected trace to the new one:
590  iter = iListSelectedTraces.begin();
591  while ( iter != iListSelectedTraces.end() )
592  {
593  this->UpdateCollectionIDOfSelectedTrace(*iter, iNewCollectionID,
594  iDatabaseConnector);
595  iter++;
596  }
597 
598  if ( !ListCollectionIDWithBoundingBoxToUpdate.empty() )
599  {
600  //while (iter != iListSelectedTraces.end())
601  // {
602  // int tempTraceID = *iter;
603  // int tempCollectionID = FindOneID(iDatabaseConnector,this->m_TracesName,
604  // this->m_CollectionIDName,this->m_TracesIDName,
605  // ConvertToString<int>(tempTraceID));
606 
607  //change the collectionID of the selected trace to the new one:
608  // this->UpdateCollectionIDOfSelectedTrace(tempTraceID,iNewCollectionID,
609  // iDatabaseConnector);
610  // if (tempCollectionID != 0)
611  // {
612  // this->RecalculateDBBoundingBox(iDatabaseConnector,tempCollectionID);
613  // ListTraceIDWithBoundingBoxUpdated.push_back(tempCollectionID);
614  // }
615  // iter++;
616  // }
617 
618  std::vector< std::string >::iterator iterVector =
619  ListCollectionIDWithBoundingBoxToUpdate.begin();
620  while ( iterVector != ListCollectionIDWithBoundingBoxToUpdate.end() )
621  {
622  std::string temp = *iterVector;
623  this->RecalculateDBBoundingBox( iDatabaseConnector, atoi( temp.c_str() ) );
624  ListTraceIDWithBoundingBoxUpdated.push_back( atoi( temp.c_str() ) );
625  iterVector++;
626  }
627  }
628 
629  //Get the max and min coordid for the bounding box:
630  int CoordMaxID;
631  int CoordMinID;
632  if ( !iListSelectedTraces.empty() )
633  {
634  CoordMaxID = this->GetCoordMaxID(iDatabaseConnector, iNewCollectionID, iListSelectedTraces);
635  CoordMinID = this->GetCoordMinID(iDatabaseConnector, iNewCollectionID, iListSelectedTraces);
636  }
637  else
638  {
639  CoordMaxID = this->GetCoordIDMaxForBoundingBoxWithNoTraces(iDatabaseConnector);
640  CoordMinID = this->GetCoordIDMinForBoundingBoxWithNoTraces(iDatabaseConnector);
641  }
642 
643  //Update the bounding box for the collection where traces are added:
644  this->UpdateBoundingBoxInDB(CoordMinID, CoordMaxID, iNewCollectionID,
645  iDatabaseConnector);
646 
647  return ListTraceIDWithBoundingBoxUpdated;
648 }*/
649 
650 //--------------------------------------------------------------------------
651 
652 //--------------------------------------------------------------------------
654 {
655  if ( this->m_TracesName == "contour" )
656  {
657  return "";
658  }
659  if ( this->m_TracesName == "mesh" )
660  {
661  return "contour";
662  }
663  if ( this->m_TracesName == "track" )
664  {
665  return "mesh";
666  }
667  if ( this->m_TracesName == "lineage" )
668  {
669  return "track";
670  }
671 
672  return "";
673 }
674 
675 //--------------------------------------------------------------------------
676 
677 //--------------------------------------------------------------------------
679  int iCoordIDMax,
680  int iTraceID,
681  vtkMySQLDatabase *iDatabaseConnector)
682 {
683  //update the bounding box for the max coord:
684  UpdateValueInDB( iDatabaseConnector, this->m_TracesName, "CoordIDMax",
685  ConvertToString< int >(iCoordIDMax), this->m_TracesIDName,
686  ConvertToString< int >(iTraceID) );
687 
688  //update the bounding box for the min coord:
689  UpdateValueInDB( iDatabaseConnector, this->m_TracesName, "CoordIDMin",
690  ConvertToString< int >(iCoordIDMin), this->m_TracesIDName,
691  ConvertToString< int >(iTraceID) );
692 }
693 
694 //--------------------------------------------------------------------------
695 
696 //--------------------------------------------------------------------------
698  vtkMySQLDatabase *iDatabaseConnector, std::list< unsigned int > iListTraces)
699 {
700  std::list< unsigned int > ListTracesFromCollectionOf = std::list< unsigned int >();
701  if ( this->m_CollectionOfName != "None" )
702  {
703  ListTracesFromCollectionOf = ListSpecificValuesForOneColumn(iDatabaseConnector,
705  this->m_TracesIDName, iListTraces);
706  }
707  return ListTracesFromCollectionOf;
708 }
709 
710 //-------------------------------------------------------------------------
711 
712 //------------------------------------------------------------------------
714  vtkMySQLDatabase *iDatabaseConnector, std::list< unsigned int > iListTracesIDs,
715  bool ExcludeZero, bool Distinct)
716 {
717  std::list< unsigned int > ListCollectionIDs = std::list< unsigned int >();
718  if ( this->m_CollectionName != "None" )
719  {
720  ListCollectionIDs = ListSpecificValuesForOneColumn(
721  iDatabaseConnector, this->m_TracesName, this->m_CollectionIDName,
722  this->m_TracesIDName, iListTracesIDs, Distinct, ExcludeZero);
723  }
724  return ListCollectionIDs;
725 }
726 
727 //-------------------------------------------------------------------------
728 
729 //------------------------------------------------------------------------
730 
732  std::list< unsigned int > iListTracesIDs, vtkMySQLDatabase *iDatabaseConnector)
733 {
734  std::vector< std::string > VectorTracesIDs =
735  ListUnsgIntToVectorString(iListTracesIDs);
736 
737  if ( !VectorTracesIDs.empty() )
738  {
740  iDatabaseConnector, this->m_TracesIDName, this->m_TracesName,
741  VectorTracesIDs, "points");
742  }
743  else
744  {
745  return std::list< unsigned int >();
746  }
747 }
748 
749 //-------------------------------------------------------------------------
750 
751 //-------------------------------------------------------------------------
753  vtkMySQLDatabase *iDatabaseConnector, int iNumberOfTraces)
754 {
755  std::vector< std::string > VectorTracesIDs = GetOrderByWithLimit(
756  iDatabaseConnector, this->m_TracesIDName, this->m_TracesName,
757  "imagingsessionid", ConvertToString< unsigned int >(this->m_ImgSessionID),
758  false, ConvertToString< int >(iNumberOfTraces) );
759 
760  return VectorStringToUnsgInt(VectorTracesIDs);
761 }
762 
763 //-------------------------------------------------------------------------
764 
765 //-------------------------------------------------------------------------
767  vtkMySQLDatabase *iDatabaseConnector, unsigned int iTraceID)
768 {
769  return GetCenterBoundingBoxes( iDatabaseConnector,
770  this->m_CollectionOfName, this->m_TracesIDName,
771  ConvertToString< unsigned int >(iTraceID) );
772 }
773 
774 //-------------------------------------------------------------------------
775 
776 //-------------------------------------------------------------------------
778  vtkMySQLDatabase *iDatabaseConnector,
779  unsigned int iCollectionID,
780  unsigned int iTimePoint)
781 {
782  FieldWithValue JoinCondition = { "CoordIDMin", "CoordID", "=" };
783 
784  std::vector< FieldWithValue > Conditions(2);
785  FieldWithValue CollectionID = { this->m_CollectionIDName, ConvertToString< unsigned int >(
786  iCollectionID), "=" };
787  Conditions[0] = CollectionID;
788  FieldWithValue TimePoint = { "TCoord", ConvertToString< unsigned int >(iTimePoint), "=" };
789  Conditions[1] = TimePoint;
790 
792  iDatabaseConnector, this->m_TracesName, "coordinate", this->m_TracesIDName, JoinCondition, Conditions);
793 }
794 
795 //-------------------------------------------------------------------------
796 
797 //-------------------------------------------------------------------------
799  vtkMySQLDatabase *iDatabaseConnector, std::list< unsigned int > iListTraceIDs)
800 {
801  std::list< unsigned int > TimePoints = std::list< unsigned int >();
802  if ( !iListTraceIDs.empty() )
803  {
804  FieldWithValue JoinCondition = { "CoordIDMin", "CoordID", "=" };
805  std::vector< std::string > VectTraceIDs = ListUnsgIntToVectorString(iListTraceIDs);
806 
807  TimePoints = GetDoublonValuesFromTwoTables(
808  iDatabaseConnector, this->m_TracesName, "coordinate",
809  "TCoord", JoinCondition, this->m_TracesIDName, VectTraceIDs);
810  }
811  return TimePoints;
812 }
813 
814 //-------------------------------------------------------------------------
815 
816 //-------------------------------------------------------------------------
818  vtkMySQLDatabase *iDatabaseConnector, std::list< unsigned int > iListTraceIDs,
819  unsigned int iTimePoint)
820 {
821  int oMaxTraceID = -1;
822 
823  if ( !iListTraceIDs.empty() )
824  {
825  FieldWithValue JoinCondition = { "CoordIDMin", "CoordID", "=" };
826  std::vector< std::string > VectTraceIDs = ListUnsgIntToVectorString(iListTraceIDs);
827  FieldWithValue TCoord = { "TCoord", ConvertToString< unsigned int >(iTimePoint), "=" };
828  oMaxTraceID = GetMaxValueFromTwoTables(iDatabaseConnector,
829  this->m_TracesName,
830  "coordinate",
831  this->m_TracesIDName,
832  JoinCondition,
833  this->m_TracesIDName,
834  VectTraceIDs,
835  TCoord);
836  }
837  return oMaxTraceID;
838 }
839 
840 //-------------------------------------------------------------------------
841 
842 //-------------------------------------------------------------------------
844  vtkMySQLDatabase *iDatabaseConnector, std::list< unsigned int > iListTraceIDs,
845  unsigned int iTimePoint, unsigned int iMaxTraceID)
846 {
847  std::list< unsigned int >::iterator iter = std::find(iListTraceIDs.begin(),
848  iListTraceIDs.end(), iMaxTraceID);
849  iListTraceIDs.erase(iter);
850  std::list< unsigned int > oListTraceIDs = std::list< unsigned int >();
851  if ( !iListTraceIDs.empty() )
852  {
853  FieldWithValue JoinCondition = { "CoordIDMin", "CoordID", "=" };
854  std::vector< std::string > VectTraceIDs = ListUnsgIntToVectorString(iListTraceIDs);
855  FieldWithValue TCoord = { "TCoord", ConvertToString< unsigned int >(iTimePoint), "=" };
856  oListTraceIDs = GetAllSelectedValuesFromTwoTables(iDatabaseConnector,
857  this->m_TracesName,
858  "coordinate",
859  this->m_TracesIDName,
860  JoinCondition,
861  this->m_TracesIDName,
862  VectTraceIDs,
863  TCoord);
864  }
865  return oListTraceIDs;
866 }
867 
868 //-------------------------------------------------------------------------
869 
870 //-------------------------------------------------------------------------
872  vtkMySQLDatabase *iDatabaseConnector, std::list< unsigned int > iListTraceIDs)
873 {
874  FieldWithValue JoinCondition = { "CoordIDMin", "CoordID", "=" };
875 
876  std::vector< std::string > VectTraceIDs = ListUnsgIntToVectorString(iListTraceIDs);
877  return GetAllSelectedValuesFromTwoTables(iDatabaseConnector,
878  this->m_TracesName, "coordinate", "TCoord", JoinCondition,
879  this->m_TracesIDName, VectTraceIDs, true);
880 }
881 
882 //-------------------------------------------------------------------------
883 
884 //-------------------------------------------------------------------------
886  vtkMySQLDatabase *iDatabaseConnector, std::list< unsigned int > iListTraceIDs,
887  unsigned int iCollectionID)
888 {
889  return ListSpecificValuesForOneColumn( iDatabaseConnector,
890  this->m_TracesName, this->m_TracesIDName,
891  this->m_TracesIDName, iListTraceIDs,
892  this->m_CollectionIDName, ConvertToString< unsigned int >(iCollectionID) );
893 }
894 
895 //-------------------------------------------------------------------------
896 
897 //-------------------------------------------------------------------------
899  vtkMySQLDatabase *iDatabaseConnector, std::list< unsigned int > iListCollectionIDs)
900 {
901  return ListSpecificValuesForOneColumn(iDatabaseConnector, this->m_TracesName,
902  this->m_TracesIDName, this->m_CollectionIDName, iListCollectionIDs);
903 }
904 
905 //-------------------------------------------------------------------------
906 
907 //-------------------------------------------------------------------------
909  vtkMySQLDatabase *iDatabaseConnector,std::list<unsigned int> iListTPs)
910 {
911  FieldWithValue JoinCondition = { "CoordIDMin", "CoordID", "=" };
912  std::vector< std::string > VectTimePoints = ListUnsgIntToVectorString(iListTPs);
913  FieldWithValue AndCondition =
914  {"imagingsessionID", ConvertToString<unsigned int>(this->m_ImgSessionID), "="};
915 
916  return GetAllSelectedValuesFromTwoTables(iDatabaseConnector, this->m_TracesName,
917  "coordinate", this->m_TracesIDName, JoinCondition, "TCoord", VectTimePoints,
918  AndCondition);
919 }
920 
921 //-------------------------------------------------------------------------
922 
923 //-------------------------------------------------------------------------
925  vtkMySQLDatabase *iDatabaseConnector, std::list< unsigned int > iListTraceIDs)
926 {
927  FieldWithValue JoinCondition = { "CoordIDMin", "CoordID", "=" };
928 
929  std::vector< std::string > VectTraceIDs = ListUnsgIntToVectorString(iListTraceIDs);
930  return GetAllSelectedValuesFromTwoTables(iDatabaseConnector,
931  this->m_TracesName, "coordinate", "TCoord", JoinCondition,
932  this->m_TracesIDName, VectTraceIDs);
933 }
934 
935 //-------------------------------------------------------------------------
936 
937 //-------------------------------------------------------------------------
938 std::list< unsigned int > GoDBCollectionOfTraces::GetTraceIDsWithTimePointInf(vtkMySQLDatabase *iDatabaseConnector,
939  std::list< unsigned int > iListTraceIDs,
940  unsigned int iTimePoint)
941 {
942  FieldWithValue JoinCondition = { "CoordIDMin", "CoordID", "=" };
943  FieldWithValue AndCondition =
944  { "TCoord", ConvertToString< unsigned int >(iTimePoint), "<" };
945 
946  std::vector< std::string > VectTraceIDs = ListUnsgIntToVectorString(iListTraceIDs);
948  iDatabaseConnector,
949  this->m_TracesName, "coordinate", this->m_TracesIDName,
950  JoinCondition, this->m_TracesIDName, VectTraceIDs, AndCondition);
951 }
952 
953 //-------------------------------------------------------------------------
954 
955 //-------------------------------------------------------------------------
956 /*unsigned int GoDBCollectionOfTraces::GetTimePointMin(
957  vtkMySQLDatabase *iDatabaseConnector, unsigned int iTraceID)
958 {
959  FieldWithValue JoinCondition = {"CoordIDMin", "CoordID", "="};
960  std::vector<std::string> TraceID(1);
961  TraceID.at(0) = ConvertToString<unsigned int>(iTraceID);
962  std::list<unsigned int> results = GetAllSelectedValuesFromTwoTables(
963  iDatabaseConnector, this->m_TracesName, "coordinate", "TCoord", JoinCondition,
964  this->m_TracesIDName, TraceID);
965  return results.front();
966  }
967 //-------------------------------------------------------------------------
968 
969 //-------------------------------------------------------------------------
970 
971 unsigned int GoDBCollectionOfTraces::GetTimePointMax(
972  vtkMySQLDatabase *iDatabaseConnector, unsigned int iTraceID)
973 {
974  FieldWithValue JoinCondition = {"CoordIDMax", "CoordID", "="};
975  std::vector<std::string> TraceID(1);
976  TraceID.at(0) = ConvertToString<unsigned int>(iTraceID);
977  std::list<unsigned int> results = GetAllSelectedValuesFromTwoTables(
978  iDatabaseConnector, this->m_TracesName, "coordinate", "TCoord", JoinCondition,
979  this->m_TracesIDName, TraceID);
980  return results.front();
981  }*/
982 //-------------------------------------------------------------------------
983 
984 //-------------------------------------------------------------------------
986  vtkMySQLDatabase *iDatabaseConnector, unsigned int iTraceID, bool MinTimePoint)
987 {
988  std::string WhichTimePoint = "CoordIDMin";
989 
990  if ( !MinTimePoint )
991  {
992  WhichTimePoint = "CoordIDMax";
993  }
994  FieldWithValue JoinCondition = { WhichTimePoint, "CoordID", "=" };
995  std::vector< std::string > TraceID(1);
996  TraceID.at(0) = ConvertToString< unsigned int >(iTraceID);
997  std::list< unsigned int > results = GetAllSelectedValuesFromTwoTables(
998  iDatabaseConnector, this->m_TracesName, "coordinate", "TCoord", JoinCondition,
999  this->m_TracesIDName, TraceID);
1000  return results.front();
1001 }
1002 
1003 //-------------------------------------------------------------------------
1004 
1005 //-------------------------------------------------------------------------
1007 {
1008  std::vector< std::string > oTraceAttributes;
1009  oTraceAttributes.push_back(this->m_TracesIDName);
1010  if (this->m_CollectionIDName != "NoneID")
1011  {
1012  oTraceAttributes.push_back(this->m_CollectionIDName);
1013  }
1014  else
1015  {
1016  oTraceAttributes.push_back("TrackIDRoot");
1017  }
1018  oTraceAttributes.push_back("Red");
1019  oTraceAttributes.push_back("Green");
1020  oTraceAttributes.push_back("Blue");
1021  oTraceAttributes.push_back("Alpha");
1022  oTraceAttributes.push_back("Points");
1023  oTraceAttributes.push_back("TCoord");
1024 
1025  return oTraceAttributes;
1026 }
1027 
1028 //-------------------------------------------------------------------------
1029 
1030 //-------------------------------------------------------------------------
1032  vtkMySQLDatabase *iDatabaseConnector,
1033  std::list<unsigned int> iListTraceIDs )
1034 {
1035  int oTraceID = -1;
1036  std::vector< std::string > SelectedFields(2);
1037  SelectedFields.at(0) = "track.trackid";
1038  SelectedFields.at(1) = "coordinate.TCoord";
1039  FieldWithValue JoinCondition = { "CoordIDMin", "CoordID", "=" };
1040  std::vector<FieldWithValue> Conditions = std::vector<FieldWithValue>();
1041  std::list<unsigned int>::iterator iter = iListTraceIDs.begin();
1042 
1043  while(iter != iListTraceIDs.end() )
1044  {
1045  unsigned int Value = *iter;
1046  FieldWithValue Condition = {this->m_TracesIDName, ConvertToString<unsigned int>(Value), "="};
1047  Conditions.push_back(Condition);
1048  ++iter;
1049  }
1050 
1051  std::vector< std::string > ResultQuery
1053  iDatabaseConnector, this->m_TracesName, "coordinate", SelectedFields,
1054  JoinCondition, Conditions, "OR", "TCoord");
1055  if (ResultQuery.size()>2)
1056  {
1057  if (ResultQuery.at(1) != ResultQuery.at(3)) //if the 2 lowest timepoints are different
1058  {
1059  oTraceID = ss_atoi<int>(ResultQuery.at(0)); //return the 1rst traceID
1060  }
1061  }
1062  return oTraceID;
1063 }
1064 //-------------------------------------------------------------------------
1065 
1066 //-------------------------------------------------------------------------
1068  vtkMySQLDatabase *iDatabaseConnector)
1069  {
1070  std::vector<std::string> VectColumnsTrackFamily(3);
1071  VectColumnsTrackFamily.at(0) = "TrackIDMother";
1072  VectColumnsTrackFamily.at(1) = "TrackIDDaughter1";
1073  VectColumnsTrackFamily.at(2) = "TrackIDDaughter2";
1074  const FieldWithValue JoinCondition = {"TrackID", "TrackIDMother", "="};
1075 
1076  return GetAllSelectedValuesFromTwoTables( iDatabaseConnector,
1077  std::string( "track" ),
1078  std::string( "trackfamily" ),
1079  VectColumnsTrackFamily,
1080  JoinCondition,
1081  std::string( "ImagingsessionID" ),
1082  ConvertToString<unsigned int>(this->m_ImgSessionID),
1083  true);
1084  }
1085 
1086 //-------------------------------------------------------------------------
1087 
1088 //-------------------------------------------------------------------------
1090  vtkMySQLDatabase *iDatabaseConnector, std::list<unsigned int> iLineagesID)
1091  {
1092  FieldWithValue JoinCondition = { "trackID", "TrackIDMother", "=" };
1093 
1094  std::vector<std::string> VectorLineages = ListUnsgIntToVectorString(iLineagesID);
1095 
1096  return GetAllSelectedValuesFromTwoTables( iDatabaseConnector, "track", "trackfamily",
1097  "trackfamily.trackfamilyID", JoinCondition, "track.lineageid", VectorLineages );
1098  }
1099 //-------------------------------------------------------------------------
1100 
1101 //-------------------------------------------------------------------------
1103  vtkMySQLDatabase *iDatabaseConnector, std::list<unsigned int> iListTrackIDs)
1104 {
1105  FieldWithValue JoinCondition = { "trackID", "trackIDMother", "=" };
1106  std::vector<std::string> VectTrackIDs = ListUnsgIntToVectorString(iListTrackIDs);
1107  std::list<unsigned int> oList = GetTwoFieldsFromTwoTables(iDatabaseConnector,
1108  this->m_TracesName, "trackfamily", JoinCondition, "track.trackfamilyID",
1109  "trackfamily.trackfamilyID", this->m_TracesIDName, VectTrackIDs, true);
1110  return oList;
1111 }
1112 //-------------------------------------------------------------------------
1113 
1114 //-------------------------------------------------------------------------
1115 std::string
1117 GetPoints(vtkMySQLDatabase *iDatabaseConnector, std::string iTraceName,
1118  unsigned int iTraceID)
1119 {
1120  // WHAT
1121  std::string QueryString = "SELECT Points ";
1122 
1123  // FROM
1124  QueryString += "FROM " + iTraceName;
1125 
1126  //WHERE
1127  // trace to Trace (mysql not case sensitive on linux but just in case)
1128  std::string traceID = iTraceName;
1129  std::transform(iTraceName.begin(), ++iTraceName.begin(),traceID.begin(), ::toupper);
1130  traceID += "ID";
1131  QueryString += " WHERE " + traceID + " = ";
1132  // iTraceID int to string
1133  std::stringstream s;
1134  s << iTraceID;
1135  QueryString += s.str();
1136 
1137  return ExecuteSelectQueryOneValue< std::string >( iDatabaseConnector,
1138  QueryString);
1139 }
1140 //-------------------------------------------------------------------------
1141 
1142 //-------------------------------------------------------------------------
1143 std::vector<unsigned int>
1145 GetTrackFamily(vtkMySQLDatabase *iDatabaseConnector, unsigned int iTrackID)
1146 {
1147  // WHAT
1148  std::string QueryString = "SELECT * ";
1149 
1150  // FROM
1151  QueryString += "FROM trackfamily ";
1152 
1153  //WHERE
1154  // iTraceID int to string
1155  std::stringstream s;
1156  s << iTrackID;
1157  std::string trackID = s.str();
1158 
1159  QueryString += " WHERE (TrackIDDaughter1=" + trackID;
1160  QueryString += " OR TrackIDDaughter2=" + trackID + ")";
1161 
1162  return ExecuteSelectQuery< std::vector<unsigned int> >( iDatabaseConnector,
1163  QueryString);
1164 }
1165 //-------------------------------------------------------------------------
1166 
1167 //-------------------------------------------------------------------------
1168 bool
1170 isMother(vtkMySQLDatabase *iDatabaseConnector, unsigned int iTrackID)
1171 {
1172  // WHAT
1173  std::string QueryString = "SELECT TrackIDMother ";
1174 
1175  // FROM
1176  QueryString += "FROM trackfamily ";
1177 
1178  //WHERE
1179  // iTraceID int to string
1180  std::stringstream s;
1181  s << iTrackID;
1182  std::string trackID = s.str();
1183 
1184  QueryString += " WHERE TrackIDMother=" + trackID;
1185 
1186  std::string result =
1187  ExecuteSelectQueryOneValue< std::string >( iDatabaseConnector, QueryString);
1188 
1189  int numb;
1190  std::stringstream(result) >> numb;
1191 
1192  bool ismother = true;
1193 
1194  if(numb <= 0)
1195  {
1196  ismother = false;
1197  }
1198 
1199  return ismother;
1200 }
1201 //-------------------------------------------------------------------------
void SafeDownCast(GoDBTraceRow &iRow)
convert a GoDBTraceRow in GoDBMeshRow
void UpdateValueForListTraces(vtkMySQLDatabase *iDatabaseConnector, std::string iNameValue, std::string iValue, std::list< unsigned int > iListTraceIDs)
update in the database the iNameValue with iValue for the traces from iListTraceIDs ...
GoDBCoordinateRow GetCollectionOfTracesCoordMax(vtkMySQLDatabase *DatabaseConnector, std::list< unsigned int > iListCollectionOfTracesID)
return the coordinate max of all the coordinates of the collectionOf traces
std::list< NameWithColorData > GetListNameWithColorDataFromResultsQuery(std::vector< std::vector< std::string > > iResultsQuery)
get the data from the query results to fill a QColor and the corresponding ID
std::list< unsigned int > GetListValuesFromTwoTablesAndCondition(vtkMySQLDatabase *iDatabaseConnector, const std::string &iTableOne, const std::string &iTableTwo, const std::string &iColumn, const FieldWithValue &iJoinCondition, const std::string &iField, const std::vector< std::string > &iVectorValues, const FieldWithValue &iAndCondition)
std::list< NameWithColorData > GetTracesIDsWithColorForATimePoint(vtkMySQLDatabase *iDatabaseConnector, unsigned int iTimePoint)
get all the distinct traces IDs with their QColor for a given timepoint
abstract class to be inherited by Contour,Mesh,Track and GoDBLineageRow
Definition: GoDBTraceRow.h:50
std::vector< std::string > GetAttributesForTraces()
std::vector< std::vector< std::string > > GetValuesFromSeveralTables(vtkMySQLDatabase *DatabaseConnector, const std::string &MainTable, const std::vector< std::string > &SelectFields, const std::string &field, const std::string &value, const std::vector< std::string > &JoinTablesOnTraceTable, bool Distinct)
void SetImgSessionID(unsigned int iImgSessionID)
set m_ImgSessionID to iImgSessionID
std::list< double * > GetCoordinateCenterBoundingBox(vtkMySQLDatabase *iDatabaseConnector, unsigned int iTraceID)
return a list of the coordinates of all the centers of the bounding boxes for all the collectionOf co...
std::list< unsigned int > GetTwoFieldsFromTwoTables(vtkMySQLDatabase *iDatabaseConnector, const std::string &iTableOne, const std::string &iTableTwo, const FieldWithValue &iOnCondition, const std::string &iColumnOne, const std::string &iColumnTwo, const std::string &iField, const std::vector< std::string > &iListValues, bool Distinct)
int GetTraceIDWithLowestTimePoint(vtkMySQLDatabase *iDatabaseConnector, std::list< unsigned int > iListTraceIDs)
return the traceID with the lowest timepoint or -1 if there is not only one that have the lowest time...
unsigned int GetBoundedBoxTimePoint(vtkMySQLDatabase *iDatabaseConnector, unsigned int iTraceID, bool MinTimePoint=true)
get the timepoint min or max for the trace
std::list< unsigned int > GetSpecificValuesEqualToZero(vtkMySQLDatabase *iDatabaseConnector, const std::string &iColumnName, const std::string &iTableName, const std::vector< std::string > &iVectorConditionFieldOne, const std::string &iFieldTwo)
int GetCoordIDMinForBoundingBoxWithNoTraces(vtkMySQLDatabase *iDatabaseConnector)
return the CoordIDMin for a minimum bounding box
void SetCollectionInfo(std::string iCollectionName, std::string iTracesName, std::string iCollectionOfName)
fill the global values for the collection of traces.
int CreateNewCollection()
Create a new collection Row in the collection table and return the collectionID from the created row:...
int GetMaxTraceIDsForSpecificTimePoint(vtkMySQLDatabase *iDatabaseConnector, std::list< unsigned int > iListTraceIDs, unsigned int iTimePoint)
get the max of the IDs for the traceIDs in iListTraceIDs that have a timepoint equal to iTimePoint ...
std::list< NameWithColorData > GetAllTracesIDsWithColor(vtkMySQLDatabase *iDatabaseConnector)
get all the distinct traces IDs with their QColor
int MinValueForOneColumnInTable(vtkMySQLDatabase *DatabaseConnector, const std::string &ColumnName, const std::string &TableName, const std::string &field, const std::vector< std::string > &VectorValues)
SELECT MIN(ColumnName) FROM TableName WHERE (field = value1 or field = value2....".
std::list< double * > GetCenterBoundingBoxes(vtkMySQLDatabase *DatabaseConnector, const std::string &iTableName, const std::string &iField, const std::string &iValue)
manages a map with keys matching fields of the gofiguredatabase Coordinate table and values of the ma...
virtual bool SetValuesForSpecificID(int ID, vtkMySQLDatabase *iDatabaseConnector)
get the data from the database corresponding to the specific ID and put them in the map ...
Definition: GoDBRow.cxx:209
void GetFieldsNeededForQueryForColorData(std::vector< std::string > &ioSelectedFields, std::vector< std::string > &ioJoinTablesOnTraceTable)
get all the different parts needed for the query to get the color of traces from the database ...
void UpdateValueInDB(vtkMySQLDatabase *DatabaseConnector, std::string iTableName, std::string iColumnName, std::string iNewValue, std::string iField, std::vector< unsigned int > iVectIDs)
std::string GetPoints(vtkMySQLDatabase *iDatabaseConnector, std::string iTraceName, unsigned int iTraceID)
int GetCoordMinID(vtkMySQLDatabase *DatabaseConnector, int iTraceID)
get the min of all the coordinates of the collectionof traces belonging to the trace and record them ...
std::list< unsigned int > GetTraceIDsBelongingToListTimePoints(vtkMySQLDatabase *iDatabaseConnector, std::list< unsigned int > iListTPs)
std::list< unsigned int > VectorStringToUnsgInt(const std::vector< std::string > &iVector)
int SaveInDB(vtkMySQLDatabase *DatabaseConnector)
save the coordinate in the database and return the ID of the new created coordinate or the ID of the ...
void DeleteTraceInDB(int TraceToDelete, vtkMySQLDatabase *DatabaseConnector)
Delete the corresponding trace in the database.
std::list< unsigned int > GetAllSelectedValuesFromTwoTables(vtkMySQLDatabase *iDatabaseConnector, const std::string &iTableOne, const std::string &iTableTwo, const std::string &iColumn, const FieldWithValue &iJoinCondition, const std::vector< FieldWithValue > &iFieldsWithValues, bool Distinct)
this class manages the map with the keys matching the fields of the Lineage gofiguredatabase table an...
std::list< unsigned int > GetLastCreatedTracesIDs(vtkMySQLDatabase *iDatabaseConnector, int iNumberOfTraces)
get the IDs of the last saved traces in the database
std::list< unsigned int > GetTimePointsForTraceIDs(vtkMySQLDatabase *iDatabaseConnector, std::list< unsigned int > iListTraceIDs)
get the timepoints (non distinct) for all the traceIDs in iListTraceIDs
std::list< unsigned int > GetListTracesIDsFromThisCollectionOf(vtkMySQLDatabase *iDatabaseConnector, std::list< unsigned int > iListTraces)
get the list of IDs belonging to the iListTraces as collectionof
this class manages the map with the keys matching the fields of the Track gofiguredatabase table and ...
Definition: GoDBTrackRow.h:49
std::list< unsigned int > GetListCollectionIDs(vtkMySQLDatabase *iDatabaseConnector, std::list< unsigned int > iListTracesIDs, bool ExcludeZero=true, bool Distinct=true)
get the list of IDs that are collection of iListTraces
void DeleteTracesInDB(std::list< unsigned int > TracesToDelete, vtkMySQLDatabase *DatabaseConnector)
Delete in the Database all the traces listed in the list of int.
void RecalculateDBBoundingBox(vtkMySQLDatabase *iDatabaseConnector, int iCollectionID)
Calculate the bounding box of the corresponding collection and update it in the database.
bool isMother(vtkMySQLDatabase *iDatabaseConnector, unsigned int iTrackID)
int MaxValueForOneColumnInTable(vtkMySQLDatabase *DatabaseConnector, const std::string &ColumnName, const std::string &TableName)
SELECT MAX(ColumnName) FROM TableName This is an overloaded member function, provided for convenience...
std::list< unsigned int > GetTrackFamilyDataFromDB(vtkMySQLDatabase *iDatabaseConnector)
std::vector< std::string > ListSpecificValuesForOneColumn(vtkMySQLDatabase *iDatabaseConnector, const std::string &TableName, const std::string &ColumnName, const std::string &field, const std::string &value, bool ExcludeZero)
SELECT ColumnName FROM TableName WHERE field = value and ColumnName <> 0 (if excludezero) ...
int FindOneID(vtkMySQLDatabase *DatabaseConnector, const std::string &TableName, const std::string &ColumnName, const std::string &field, const std::string &value)
SELECT ColumnName FROM TableName WHERE field = value.
GoDBCoordinateRow GetCollectionOfTracesCoordMin(vtkMySQLDatabase *DatabaseConnector, std::list< unsigned int > iListCollectionOfTracesID)
return the coordinate min of all the coordinates of the selected traces
std::list< unsigned int > GetTrackFamiliesForLineages(vtkMySQLDatabase *iDatabaseConnector, std::list< unsigned int > iLineagesID)
std::list< unsigned int > GetDoublonValuesFromTwoTables(vtkMySQLDatabase *iDatabaseConnector, const std::string &iTableOne, const std::string &iTableTwo, const std::string &iColumn, const FieldWithValue &iJoinCondition, const std::string &iField, const std::vector< std::string > &iVectValues)
std::list< unsigned int > GetListTracesIDWithNoPoints(std::list< unsigned int > iListTracesIDs, vtkMySQLDatabase *iDatabaseConnector)
get the list of tracesIDs that have no points
std::list< unsigned int > GetTraceIDsBelongingToCollectionID(vtkMySQLDatabase *iDatabaseConnector, std::list< unsigned int > iListTraceIDs, unsigned int iCollectionID)
get the tracesIDs contained in iListTraceIDs that have iCollectionID as a collectionID ...
void SetTheTimePointCoordinatesForMesh(unsigned int iTimePoint, int &ioCoordIDMax, int &ioCoordIDMin, vtkMySQLDatabase *iDatabaseConnector)
modify the timepoint to iTimePoint for the coordmax and coordmin and replace the ioCoordIDMax/Min wit...
std::list< unsigned int > GetTraceIDsWithTimePointAndCollectionID(vtkMySQLDatabase *iDatabaseConnector, unsigned int iCollectionID, unsigned int iTimePoint)
get the tracesIDs from the database which have iTimePoint as TCoordMin and iCollectionID as collectio...
std::pair< std::string, QColor > NameWithColorData
void UpdateBoundingBoxInDB(int iCoordIDMin, int iCoordIDMax, int iTraceID, vtkMySQLDatabase *iDatabaseConnector)
Update in the database the coordid max and min of the trace.
std::vector< std::string > GetVectorColumnNames()
put all the keys of the map in a vector
Definition: GoDBRow.cxx:123
void SetField(const std::string &key, const T &value)
convert the value into a string and assign it to the key in the map
Definition: GoDBRow.h:73
std::list< unsigned int > GetTrackFamilyID(vtkMySQLDatabase *iDatabaseConnector, std::list< unsigned int > iListTrackIDs)
return the trackFamilyIDs the track belongs to (as a mother or as a daughter)
int GetCoordMaxID(vtkMySQLDatabase *DatabaseConnector, int iTraceID)
get the max of all the coordinates of the collectionof traces belonging to the trace and record them ...
std::list< unsigned int > GetTraceIDsWithTimePointInf(vtkMySQLDatabase *iDatabaseConnector, std::list< unsigned int > iListTraceIDs, unsigned int iTimePoint)
get the tracesIDs belonging to iListTraceIDs with a timepoint inf to iTimePoint
this class manages the map with the keys matching the fields of the Mesh gofiguredatabase table and v...
Definition: GoDBMeshRow.h:55
void DeleteRow(vtkMySQLDatabase *DatabaseConnector, std::string TableName, std::string field, std::string value)
std::list< unsigned int > GetTimePointWithSeveralTracesFromTheList(vtkMySQLDatabase *iDatabaseConnector, std::list< unsigned int > iListTraceIDs)
get the list of timepoints where several traces from the list of traces have the same ones ...
int GetMaxValueFromTwoTables(vtkMySQLDatabase *iDatabaseConnector, const std::string &iTableOne, const std::string &iTableTwo, const std::string &iColumn, const FieldWithValue &iJoinCondition, const std::string &iField, const std::vector< std::string > &iVectorValues, const FieldWithValue &iAndCondition)
std::vector< unsigned int > GetTrackFamily(vtkMySQLDatabase *iDatabaseConnector, unsigned int iTrackID)
std::vector< std::string > ListUnsgIntToVectorString(const std::list< unsigned int > &iList)
int GetCoordIDMaxForBoundingBoxWithNoTraces(vtkMySQLDatabase *iDatabaseConnector)
return the CoordIDMax for a minimum bounding box
std::vector< std::string > GetOrderByWithLimit(vtkMySQLDatabase *iDatabaseConnector, const std::string &iColumnName, const std::string &iTableName, const std::string &iField, const std::string &iValue, bool ASC, const std::string &iNumberLimit)
std::list< unsigned int > GetNonMaxTraceIDsForSpecificTimePoint(vtkMySQLDatabase *iDatabaseConnector, std::list< unsigned int > iListTraceIDs, unsigned int iTimePoint, unsigned int iMaxTraceID)
get all the traceIDs except the iMaxTraceID for the timepoint
void UpdateCollectionIDOfSelectedTrace(int iSelectedTraceID, int inewCollectionID, vtkMySQLDatabase *DatabaseConnector)
change the collection ID of the trace
void UpdateCollectionIDOfSelectedTraces(std::list< unsigned int > iListSelectedTraces, unsigned int iCollectionID, vtkMySQLDatabase *iDatabaseConnector)
Update the collectionID of the selected traces in the DB traces table with the new collectionID...
std::list< unsigned int > GetListTimePointsFromTraceIDs(vtkMySQLDatabase *iDatabaseConnector, std::list< unsigned int > iListTraceIDs)
get the list of timepoints for each trace in iListTraceIDs