#ifndef _INC_GEOMETRIC
#define _INC_GEOMETRIC

#include "stdafx.h"
#include "itkImage.h"
#include "itkSmartPointer.h"
#include <itkLightObject.h> 

#define medialNode 0
#define boundaryNode 1
#define internalNode 2

namespace mial{

    //! Topological characteristics of the organism
    /*! The geometrical layer of a deformable organism
    is responsible for managing the physical instantiation of the organisms body. Hence,
    the geometrical ABC serves as the storage point for the organisms
    topology.

        \param dType The data type used for numerical storage.
        \param nDims The number of dimensions.
        \param MType The matrix type used for internal matrix storage. Defaults to vnl_matrix<dType>. Only vnl is supported at this time.
        \param VType The vector type used for internal vector storage. Defaults to vnl_vector<dType>. Only vnl is supported at this time.

    */
    template < class dType, int nDims, class MType = vnl_matrix<dType>, class VType = vnl_vector<dType> >
	class Geometric:public itk::LightObject
    {
    public:

		//Smartpointer
		typedef Geometric Self;
		typedef itk::SmartPointer<Self>  Pointer;
		typedef itk::SmartPointer<const Self>  ConstPointer;
		typedef itk::WeakPointer<const Self>  ConstWeakPointer;
		//itkNewMacro(Self);

		//! The internal vector type
        typedef VType                                   VectorType;

        //! The internal matrix type
        typedef MType                                   MatrixType;

        //! The type of binary image
        typedef typename itk::Image< unsigned char, nDims>      BinaryImageType;

    protected:
		//! Default constructor
		Geometric(){numNodes =0;numConnections=0; topologyChange = true;nodesChange = true;};

        //! An numNodes by nDims matrix containing all the nodes of the organism.
        /*!
            This must be updated anytime a derived class changes
            its own representation of nodes. This ensures a
            consistent data representation is available to all
            classes. However, for greater efficiency one could
            override the accessors to this function and therefore
            avoid doing the update; as the variable would never be
            accessed.
        */
        MatrixType mNodes;

        //! A vector containing classifiers for all nodes.
        /*!
            Numerous #defines are supported, and can be overridden
            at risk of breaking compatibility with existing
            functionality.

            0 - medialNode
            1 - boundaryNode
            2 - internalNode
        */
        VectorType nodeClass;

        //! A numConnections by 2 matrix containing connections between nodes as rows.
        /*!
            This must be updated anytime a derived class changes
            its own representation of the topology. This ensures a
            consistent data representation is available to all
            classes. However, for greater efficiency one could
            override the accessors to this function and therefore
            avoid doing the update; as the variable would never be
            accessed.
        */
        MatrixType mConnections;

		//! A vector containing classifiers for all connections.
        /*!
            Numerous #defines are supported, and can be overridden
            at risk of breaking compatibility with existing
            functionality.

            0 - medialNode
            1 - boundaryNode
            2 - internalNode
        */
        VectorType connectionClass;



        //! The number of nodes. Must be updated by derived classes when new nodes are added.
        unsigned int numNodes;

        //! The number of connections between nodes. Must be updated by derived classes when new connections are added.
        unsigned int numConnections;

        //! A state variable denoting a change in topology.
        /*!
            Set this variable true whenever a change in topology
            occurs. Any objects keeping local copies of topology
            (physic layers, etc) should check this state before
            running.
        */
        bool topologyChange;

        //! A state variable denoting a change in node positions.
        /*!
            Set this variable true whenever a change in position
            or count of the nodes occurs. Any objects keeping local copies of topology
            (physic layers, etc) should check this state before
            running.
        */
        bool nodesChange;
    public:

        struct Error{
            std::string msg;
        };

		virtual VectorType getCentroid(){
			VectorType pos = VectorType(nDims);
			pos.fill(0);
			for(int i=0;i<numNodes;i++)
			{
				pos = pos + mNodes.get_row(i);
			}
			pos = pos/numNodes;
			return pos;};

        
        //! Pure virtual member.
        /*!
            Set the matrix node positions at particular rows.
            \param pos The new positions.
            \param rows The rows to change.
        */
        virtual bool setMatrixNodePositions(MatrixType pos,int* rows)=0;

        //! Pure virtual member.
        /*!
            Set the matrix node positions for all nodes.
            \param pos the positions
        */
        virtual bool setMatrixNodePositions(MatrixType pos)=0;

        //! Accessor returning the number of nodes.
        unsigned int getNumNodes(){return numNodes;};
        

        //! Pure virtual member function.
        /*!
            Adds nodes to the organism, should be ran in
            conjunction with addConnection. Implementations should
            correctly update the topology, and change the state
            variables.
        */
        virtual bool addNodes(MatrixType nodes,VectorType classes)=0;

		//! Pure virtual member function.
        /*!
            Adds a connection between nodes in the organism, should be ran in
            conjunction with addNode. Implementations should
            correctly update the topology, and change the state
            variables.
        */
        virtual bool addConnection(int a, int b)=0;

        
        //! Pure virtual member function.
        /*!
            Removes a node from the organism. Implementations must
            make sure to correctly update the topology, and set
            the state variables.

            \param index The index of the node to be removed.
        */
        virtual bool removeNode(int index)=0;

        //! Pure virtual member function. Returns the matrix node positions.
        /*!
            Implementation should update the matrix node positions before returning, hence why this is a pure virtual.
        */
        virtual MatrixType getMatrixNodePositions()=0;

        //! Pure virtual member function. Returns the matrix of connections.
        /*!
            Implementation should update the matrix connections before returning, hence why this is a pure virtual.
        */
        virtual MatrixType getMatrixConnections()=0;

        //! Pure virtual member function. Writes the nodes to a file.
        /*!
            Implementation should update the matrix positions before calling, hence why this is a pure virtual.
        */
        virtual void writeNodesToFile(std::string fileName) = 0;


        //! Pure virtual member function. Reads the nodes from a file.
        /*!
            Derived class will need to update its own internal topology representation.
        */
        virtual void readNodesFromFile(std::string fileName) = 0;

        //! Pure virtual member function. Creates an organism from a binary mask.
		/*!
            Any implementation of this method should produce a deformable organism from a binary image.
        */
        virtual void generateTopologyFromBinaryImage( typename BinaryImageType::Pointer binaryInputImage ) = 0;

		//! Pure virtual member function. Creates a binary mask image from the organism
        /*!
            Any implementation of this method should a binary image.
        */
		virtual typename itk::Image< unsigned char, nDims>::Pointer generateBinaryImageFromTopology( typename BinaryImageType::SizeType )=0;

        //! Accessor for the number of connections.
        unsigned int getNumConnections(){return numConnections;};

        //! Accessor for topology change
        /*!
            TODO: Decide if should be smart enough to know who is asking. Keep a list of clients.
        */
        bool didTopologyChange(){if(topologyChange){topologyChange = false;return true;}else{return false;}};

        //! Accessor for node position change
        /*!
            TODO: Decide if should be smart enough to know who is asking. Keep a list of clients.
        */
        bool didNodesChange(){if(nodesChange){nodesChange = false;return true;}else{return false;}};

		
    private:

        //! Pure virtual member that updates the matrix node positions.
        virtual void updateMatrixNodePositions()=0;

        //! Pure virtual member that updates the matrix connections.
        virtual void updateMatrixConnections()=0;
    };
}//end mial #include "Geometric.cxx"
#endif /*_INC_GEOMETRIC*/