block.h

/*
    This file is part of Nori, a simple educational ray tracer
 
    Copyright (c) 2015 by Wenzel Jakob, Romain Prévost
 
    Nori is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License Version 3
    as published by the Free Software Foundation.
 
    Nori 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 General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
 
/* =======================================================================
     This file contains classes for parallel rendering of "image blocks".
 * ======================================================================= */
 
#if !defined(__NORI_PARALLEL_H)
#define __NORI_PARALLEL_H
 
#include <nori/color.h>
#include <nori/vector.h>
#include <tbb/mutex.h>
 
#define NORI_BLOCK_SIZE 32 /* Block size used for parallelization */
 
NORI_NAMESPACE_BEGIN
 
class ImageBlock : public Eigen::Array<Color4f, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor> {
public:
    ImageBlock(const Vector2i &size, const ReconstructionFilter *filter);
    
    ~ImageBlock();
 
    void init(const Vector2i &size, const ReconstructionFilter *filter);
    
    void setOffset(const Point2i &offset) { m_offset = offset; }
 
    inline const Point2i &getOffset() const { return m_offset; }
    
    void setSize(const Point2i &size) { m_size = size; }
 
    inline const Vector2i &getSize() const { return m_size; }
 
    inline int getBorderSize() const { return m_borderSize; }
 
    inline uint32_t getBlockId() const { return m_blockId; }
    void setBlockId(uint32_t id) { m_blockId = id;}
 
    Bitmap *toBitmap() const;
 
    void fromBitmap(const Bitmap &bitmap);
 
    void clear() { setConstant(Color4f()); }
 
    void put(const Point2f &pos, const Color3f &value);
 
    void put(ImageBlock &b);
 
    inline void lock() const { m_mutex.lock(); }
    
    inline void unlock() const { m_mutex.unlock(); }
 
    std::string toString() const;
protected:
    Point2i m_offset;
    Vector2i m_size;
    int m_borderSize = 0;
    float *m_filter = nullptr;
    float m_filterRadius = 0;
    float *m_weightsX = nullptr;
    float *m_weightsY = nullptr;
    float m_lookupFactor = 0;
    uint32_t m_blockId; // id given by the block generator
    mutable tbb::mutex m_mutex;
};
 
class BlockGenerator {
public:
    BlockGenerator(const Vector2i &size, int blockSize);
    
    bool next(ImageBlock &block);
 
    void reset();
 
    int getBlockCount() const { return m_blocksLeft; }
protected:
    enum EDirection { ERight = 0, EDown, ELeft, EUp };
 
    Point2i m_block;
    Vector2i m_numBlocks;
    Vector2i m_size;
    int m_blockSize;
    int m_numSteps;
    int m_blocksLeft;
    int m_stepsLeft;
    int m_direction;
    tbb::mutex m_mutex;
};
 
NORI_NAMESPACE_END
 
#endif /* __NORI_PARALLEL_H */