GraphNode.hpp

/*
 *  Copyright 2011, 2012 Lukas Jirkovsky
 *
 *  This file is part of FotoSHOCKcore.
 *
 *  FotoSHOCKcore is free software: you can redistribute it and/or modify it
 *  under the terms of the GNU Lesser General Public License as published by
 *  the Free Software Foundation, version 3 of the License.
 *
 *  FotoSHOCKcore is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public License
 *  along with FotoSHOCKcore.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef GRAPHNODE_H
#define GRAPHNODE_H

#include "UpdateInfo.hpp"
#include "IO/ImageIO.hpp"
#include "ImageOperation.hpp"

namespace FotoSHOCKcore{

class GraphManager;
class Graph_private;
class ImageBufferBase;
class MipMap;
class RootLoadImage;
class RootCreateImage;


class GraphNode {
    public:
        friend class GraphManager;
        friend class Graph_private;
        friend class UpdateInfo;
        friend class RootLoadImage;
        friend class RootCreateImage;


        ~GraphNode();


        MipMap* getMipMap();

        ImageBufferBase* getBuffer(const int mipmapLevel = 0);


        void saveBuffer(IO::SaveInfo info);


        const float getElapsedTime() const;


        const unsigned int id() const;


        void recalculate();

//         /// Interrupt the currently running recalculation.
//         /**
//          * Interrupts the thread which recalculates the operations in the graph.
//          * The thread is interrupted the next time it enters one of the predefined interruption points.
//          */
//         void interruptRecalculate();
// 
//         /// Wait for the recalculate thread to complete.
//         void join();


        void confirmOperation();


        void enabled(bool enable);

        bool tryEnable();


        const bool enabled() const;


        ImageOperation* operation() const;


        ImageOperationDescriptor* operationDescriptor() const;


        boost::shared_ptr<UpdateInfo> addROI(UpdateInfo updInfo);
        boost::shared_ptr<UpdateInfo> addROI(ROIinfo ROI);
        boost::shared_ptr<UpdateInfo> addROI(unsigned int x, unsigned int y, unsigned int sizeX, unsigned int sizeY, const int mipmapLevel);

        void deleteROI(boost::shared_ptr<UpdateInfo> ROI);


        const std::vector<GraphNode*>& parents() const;

        const std::vector<GraphNode*>& children() const;
    protected:

        GraphNode(unsigned int id, GraphManager* manager, ImageOperationDescriptor* operationDescr);

        bool checkInputs();
    private:

        MipMap* m_buffer;

        bool m_cache;

        ImageOperationDescriptor* m_operationDescriptor;

        ImageOperation* m_operation;


        const unsigned int m_nodeID;


        Inputs m_inputs;

        Outputs m_outputs;
        
        float m_timeTaken;

        bool m_active;

        long m_stamp;
        bool m_enabled;

        unsigned int m_distance;

        std::vector<GraphNode*> m_parents;
        std::vector<GraphNode*> m_children;

        // TODO: add some checks (if the vector is empty etc)

        std::vector<GraphNode*>& parentsRW();
        void setParents(std::vector<GraphNode*> parents);
        void setParent(std::size_t position, GraphNode* parent);
        void addParent(GraphNode* parent);

        // TODO: add some checks (if the vector is empty etc)

        std::vector<GraphNode*>& childrenRW();
        void addChild(GraphNode* child);


        void updateInputs();


        std::vector<boost::shared_ptr<UpdateInfo> > m_updateInfo;


        unsigned char m_visited;

        GraphManager* m_manager;


        void checkROI(UpdateInfo& info);


        void invalidateStamp();


        bool runOperation();

        bool runOperation(UpdateInfo& info);


        void createBuffer(unsigned int width, unsigned int height, PixelData format, unsigned int tileExtent, bool allocateTiles = true);

        void createBuffer(ImageBufferBase* buffer);

        void createBuffer(MipMap* buffer);


        void setBuffer(MipMap* buffer);

        void cleanBuffer();
};

}

#endif