class ImageFinder
{
public:
- ///====================================================================
+ //====================================================================
/// Ctor
ImageFinder(TreeHandler* tree);
/// Dtor
~ImageFinder();
- ///====================================================================
+ //====================================================================
/*
struct UpdateSummary
{
};
*/
- ///
-
-
+ ///Returns if the file can be read or not
bool IsHandledFile( const std::string& filename);
bool AddFile( const std::string& filename );
// UpdateSummary& summary );
//=====================================================================
///
/// TAKE CARE : For the moment it only supports a **SINGLE USER**
+
+ ///Class that allows parallel lectures of several images
class MultiThreadImageReader : public MultiThreadImageReaderUser
{
public:
protected:
int GetMaximalPriorityWithoutLocking();
- //
+ ///Class that represents an image to be loaded
class ImageToLoad
{
public:
* \ingroup Model
*/
//=======================================================================
- /// Concrete TreeHandler which manages a tree stored in a sqlite database
+ /// Concrete TreeHandler which manages a Tree stored in a sqlite database
class SQLiteTreeHandler : virtual public TreeHandler
{
public:
- ///====================================================================
+ //====================================================================
/// Ctor with database file name
SQLiteTreeHandler(const std::string& filename);
/// Dtor
virtual ~SQLiteTreeHandler();
- ///====================================================================
+ //====================================================================
- ///====================================================================
+ //====================================================================
/// Returns the sqlite db file name
const std::string& GetFileName() const { return mFileName; }
- ///====================================================================
+ //====================================================================
- ///====================================================================
- /// QUERY METHODS
+ //====================================================================
+ // QUERY METHODS
/// Is the 'source' readable ?
virtual bool IsReadable() { return true; }
/// Is the 'source' writable ?
virtual bool IsWritable() { return true; }
- ///====================================================================
+ //====================================================================
- ///====================================================================
- /// INITIALIZATION / FINALIZATION
- ///====================================================================
+ //====================================================================
+ // INITIALIZATION / FINALIZATION
+ //====================================================================
- ///====================================================================
+ //====================================================================
/// Opens an existing 'source'
- /// Default mode is read only
- /// If IsWritable and writable==true then opens in read/write mode
+ // Default mode is read only
+ // If IsWritable and writable==true then opens in read/write mode
virtual bool Open(bool writable = false);
/// Closes the 'source'
virtual bool Close();
/// Creates a new 'source'
- /// Default mode is read only
- /// If IsWritable and writable==true then opens in read/write mode
+ // Default mode is read only
+ // If IsWritable and writable==true then opens in read/write mode
virtual bool Create(bool writable = false);
/// Destroys the 'source'
virtual bool Destroy();
- ///====================================================================
+ //====================================================================
- ///====================================================================
+ //====================================================================
// READ METHODS
- ///====================================================================
+ //====================================================================
- ///====================================================================
+ //====================================================================
/// Returns the number of children of the Node *WITHOUT LOADING THEM*
- /// REM : The Tree itself is a Node and asking for its number of
- /// children returns the number of children of level 1.
+ // REM : The Tree itself is a Node and asking for its number of
+ // children returns the number of children of level 1.
virtual unsigned int GetNumberOfChildren(tree::Node* n);
- ///====================================================================
+ //====================================================================
- ///====================================================================
+ //====================================================================
/// Recursively loads the children of node 'parent' until maxlevel
- /// is reached.
- /// If parent == NULL or parent == tree then starts with the 'children' of
- /// the tree itself.
- /// Returns the total number of children loaded.
+ // is reached.
+ // If parent == NULL or parent == tree then starts with the 'children' of
+ // the tree itself.
+ // Returns the total number of children loaded.
virtual int LoadChildren(tree::Node* parent, int maxlevel);
- ///====================================================================
+ //====================================================================
- ///====================================================================
+ //====================================================================
/// Unloads the Node and its descendants
- /// WITHOUT altering the source, e.g. the database
+ // WITHOUT altering the source, e.g. the database
virtual void UnLoad(tree::Node* n);
///====================================================================
- ///====================================================================
- /// WRITE METHODS : WORK ONLY IN WRITE MODE
- ///====================================================================
+ //====================================================================
+ // WRITE METHODS : WORK ONLY IN WRITE MODE
+ //====================================================================
/// Adds a branch in the tree with the attributes provided
- /// returns the Level in the tree where the branch was connected
- /// (-1 for error, 0 for top level, etc. )
- /// Of course the branch is loaded on exit
+ // returns the Level in the tree where the branch was connected
+ // (-1 for error, 0 for top level, etc. )
+ // Of course the branch is loaded on exit
virtual int AddBranch( const AttributeMapType& attr );
- /// Removes the node and its descendants
+ // Removes the node and its descendants
virtual bool Remove(tree::Node*);
- /// Sets an attribute of a Node
+ // Sets an attribute of a Node
virtual bool SetAttribute(tree::Node*,
const std::string& key,
const std::string& value);
//======================================================================
//======================================================================
+
/// Returns the parent to which the branch defined by the attributes
- /// provided must be grafted
+ // provided must be grafted
tree::Node* DBGetParent( const AttributeMapType& attr);
//======================================================================
//======================================================================
+
/// Loads the children of Node parent
- /// Can recurse to numberoflevels levels
- /// \return The total number of Node loaded (may be at different levels)
+ // Can recurse to numberoflevels levels
+ // \return The total number of Node loaded (may be at different levels)
int DBLoadChildren( tree::Node* parent, int numberoflevels = 1);
//======================================================================
//======================================================================
+
/// Appends to string s the SQL command to set the attributes values
- /// of node n
+ // of node n
void SQLAppendAttributesValues(tree::Node* n, std::string& s);
//======================================================================
//======================================================================
+
/// Graft the branch defined by the attributes to the parent
void DBGraftToParent( tree::Node* parent, const AttributeMapType& attr);
//======================================================================
//======================================================================
+
/// Sets an attribute of a Node and updates the database
bool DBSetAttribute(tree::Node*,
const std::string& key,
const std::string& value);
//======================================================================
//======================================================================
+
/// Inserts the Node in the database
void DBInsert(tree::Node* n);
//======================================================================
* \ingroup Model
*/
//=====================================================================
- /// Abstract class to store user data on a tree
+ /// Abstract class to store user data on a Tree
struct TreeData
{
TreeData() {}
//=====================================================================
//=====================================================================
- /// An attributed tree structure
+ /// An attributed Tree structure
/**
*/
class Tree : public Node
* \ingroup Model
*/
//=====================================================================
- /// Descriptor of an attribute of a node of a tree (name, dicom group/element)
+ /// Descriptor of an attribute of a node of a Tree (name, dicom group/element)
class AttributeDescriptor
{
public:
//===================================================================
// Patient comparators
+ ///Compares the names of the patients
STRING_FIELD_COMP(PatientName,"A0010_0010");
+ ///Compares the sex of the patients
STRING_FIELD_COMP(PatientSex, "A0010_0040");
+ ///Compares the birthdays of the patients
STRING_FIELD_COMP(PatientBirthday, "A0010_0030");
//===================================================================
//===================================================================
// Study comparators
+ ///Compares the dates of the studies
STRING_FIELD_COMP(StudyDate,"A0008_0020");
+ ///Compares the description of the studies
STRING_FIELD_COMP(StudyDescription,"A0008_1030");
//===================================================================
//===================================================================
// Series comparators
+ ///Compares the modality of the series
STRING_FIELD_COMP(Modality,"A0008_0060");
+ ///Compares the description of the series
STRING_FIELD_COMP(SeriesDescription,"A0008_103E");
+ ///Compares the date of the series
STRING_FIELD_COMP(SeriesDate,"A0008_0021");
//===================================================================
//===================================================================
// Image comparators
+ ///Compares the number of the images
INT_FIELD_COMP(ImageNumber,"A0020_0013");
+ ///Compares the location of the images
FLOAT_FIELD_COMP(SliceLocation,"A0020_1041");
+ ///Compares the filename of the images
STRING_FIELD_COMP(FullFileName,"FullFileName");
//===================================================================
} // namespace tree
/**
* \ingroup Model
*/
- //=====================================================================
- /** Descriptor of the structure a tree
- * (number of levels, descriptors of each level, ...).
- * Any tree has at least one level (level 0) of name "Root"
- */
+
+ ///Descriptor of the structure of a Tree (number of levels, descriptors of each level, ...).
+ //Any Tree has at least one level (level 0) of name "Root"
+
class Descriptor
{
public:
* \ingroup Model
*/
//=======================================================================
+
/// Abstract class which 'handles' a Tree structure
class TreeHandler
{
public:
- ///====================================================================
+ //====================================================================
// typedef TreeHandlerStatistics Statistics;
- ///====================================================================
+ //====================================================================
- ///====================================================================
+ //====================================================================
/// Ctor
TreeHandler() {}
/// Virtual dtor
virtual ~TreeHandler() {}
- ///====================================================================
+ //====================================================================
- ///====================================================================
+ //====================================================================
/// Returns the Tree handled
tree::Tree& GetTree() { return mTree; }
/// Returns the Tree handled (const)
const tree::Tree& GetTree() const { return mTree; }
- ///====================================================================
+ //====================================================================
- ///====================================================================
- /// QUERY METHODS
+ //====================================================================
+ // QUERY METHODS
/// Is the 'source' readable ?
virtual bool IsReadable() { return false; }
/// Is the 'source' writable ?
virtual bool IsWritable() { return false; }
- ///====================================================================
+ //====================================================================
- ///====================================================================
- /// INITIALIZATION / FINALIZATION
- ///====================================================================
+ //====================================================================
+ // INITIALIZATION / FINALIZATION
+ //====================================================================
- ///====================================================================
+ //====================================================================
/// Opens an existing 'source'
- /// Default mode is read only
- /// If IsWritable and writable==true then opens in read/write mode
+ // Default mode is read only
+ // If IsWritable and writable==true then opens in read/write mode
virtual bool Open(bool writable = false) { return false; }
/// Closes the 'source'
virtual bool Close() { return false; }
/// Creates a new 'source'
- /// Default mode is read only
- /// If IsWritable and writable==true then opens in read/write mode
+ // Default mode is read only
+ // If IsWritable and writable==true then opens in read/write mode
virtual bool Create(bool writable = false) { return false; }
/// Destroys the 'source'
virtual bool Destroy() { return false; }
- ///====================================================================
+ //====================================================================
- ///====================================================================
+ //====================================================================
// READ METHODS
- ///====================================================================
+ //====================================================================
- ///====================================================================
+ //====================================================================
/// Returns the number of children of the Node *WITHOUT LOADING THEM*
- /// REM : The Tree itself is a Node and asking for its number of
- /// children returns the number of children of level 1.
+ // REM : The Tree itself is a Node and asking for its number of
+ // children returns the number of children of level 1.
virtual unsigned int GetNumberOfChildren(tree::Node* n) { return 0; }
- ///====================================================================
+ //====================================================================
- ///====================================================================
+ //====================================================================
/// Recursively loads the children of node 'parent' until maxlevel
- /// is reached.
- /// If maxlevel <= 0 then loads all the sub-tree rooted at parent
- /// If parent == NULL or parent == tree then starts with the 'children' of
- /// the tree itself.
- /// Returns the total number of children loaded.
+ // is reached.
+ // If maxlevel <= 0 then loads all the sub-tree rooted at parent
+ // If parent == NULL or parent == tree then starts with the 'children' of
+ // the tree itself.
+ // Returns the total number of children loaded.
virtual int LoadChildren(tree::Node* parent, int maxlevel)
{ return 0; }
- ///====================================================================
+ //====================================================================
- ///====================================================================
+ //====================================================================
/// Unloads the Node and its descendants
- /// WITHOUT altering the source, e.g. the database
+ // WITHOUT altering the source, e.g. the database
virtual void UnLoad(tree::Node* n) { return; }
- ///====================================================================
+ //====================================================================
- ///====================================================================
- /// WRITE METHODS : WORK ONLY IN WRITE MODE
- ///====================================================================
+ //====================================================================
+ // WRITE METHODS : WORK ONLY IN WRITE MODE
+ //====================================================================
typedef tree::Node::AttributeMapType AttributeMapType;
- /// Adds a branch in the tree with the attributes provided
- /// returns the Level in the tree where the branch was connected
- /// (-1 for error, 0 for top level, etc. )
- /// Of course the branch is loaded on exit
+ /// Adds a branch in the tree with the attributes provided
+ // returns the Level in the tree where the branch was connected
+ // (-1 for error, 0 for top level, etc. )
+ // Of course the branch is loaded on exit
virtual int AddBranch( const AttributeMapType& ) { return -1; }
/// Removes the node and its descendants
virtual bool Remove(tree::Node*) { return false; }
virtual bool SetAttribute(tree::Node*,
const std::string& key,
const std::string& value) { return false; }
- ///====================================================================
+ //====================================================================
private:
/*
//=======================================================================
/// Memorizes statistics on operations done by a tree handler
- /// (nodes created, removed, ...)
+ // (nodes created, removed, ...)
class TreeHandlerStatistics
{
public:
- ///====================================================================
+ //====================================================================
/// Ctor
TreeHandler(TreeHandler* tree) : mTreeHandler(tree) { Reset(); }
/// Dtor
namespace tree
{
- /**
+ /**
* \ingroup Model
*/
//=====================================================================
- /// Descriptor of a level of a tree (name, attributes, ...)
+ /// Descriptor of a level of a Tree (name, attributes, ...)
class LevelDescriptor
{
public:
//=====================================================================
//=====================================================================
- /// Abstract class to store user data on a tree node
+ /// Abstract class to store user data on a Tree node
struct NodeData
{
NodeData() {}
//=====================================================================
- /// Node of an attributed tree structure
+ /// Node of an attributed Tree structure
class Node
{
public:
git://git.creatis.insa-lyon.fr / creaImageIO.git / commitdiff