CRNBlock.h

Go to the documentation of this file.

/* Copyright 2006-2016 INSA Lyon, CoReNum, ENS-Lyon
 * 
 * This file is part of libcrn.
 * 
 * libcrn 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, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * libcrn 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 libcrn.  If not, see <http://www.gnu.org/licenses/>.
 * 
 * file: CRNBlock.h
 * \author Yann LEYDIER, Asma OUJI
 */

#ifndef CRNBLOCK_HEADER
#define CRNBLOCK_HEADER

#include <CRNSavable.h>
#include <CRNGeometry/CRNRect.h>
#include <CRNData/CRNMap.h>
#include <CRNData/CRNVector.h>
#include <CRNImage/CRNImage.h>
#include <CRNImage/CRNImageGradient.h>
#include <CRNBlockPtr.h>

namespace crn
{
    namespace xml
    {
        class Document;
    }
    /****************************************************************************/
    class Block: public Savable
    {
        public:
            static SBlock New(const SImage &src, const String &nam = U"");
            static SBlock New(const Path &ifname, const Path &xfname, const String &nam = U"");
            virtual ~Block() override;

            Block(const Block&) = delete;
            Block& operator=(const Block&) = delete;
            Block(Block&&) = delete;
            Block& operator=(Block&&) = delete;

            void SetFilename(const Path &nam) { setFilename(nam); }

            const Rect& GetAbsoluteBBox() const noexcept { return bbox; }
            Rect GetRelativeBBox() const;
            void SetAbsoluteBBox(const Rect &newbox);
            void SetRelativeBBox(Rect newbox);

            WBlock GetParent() { return parent; }
            WCBlock GetParent() const { return parent; }
            WBlock GetTop();
            const String& GetParentTree() const noexcept { return parenttree; }
            bool IsParent(const Block &b) const;

            SBlock AddChildAbsolute(const String &tree, Rect clip);
            SBlock AddChildAbsolute(const String &tree, Rect clip, const String &name);
            SBlock AddChildAbsoluteAt(const String &tree, Rect clip, size_t pos);
            SBlock AddChildAbsoluteAt(const String &tree, Rect clip, const String &name, size_t pos);
            SBlock AddChildRelative(const String &tree, Rect clip);
            SBlock AddChildRelative(const String &tree, Rect clip, const String &name);
            SBlock AddChildRelativeAt(const String &tree, Rect clip, size_t pos);
            SBlock AddChildRelativeAt(const String &tree, Rect clip, const String &name, size_t pos);
            size_t GetNbChildren(const String &tree) const;
            SBlock GetChild(const String &tree, size_t num);
            SCBlock GetChild(const String &tree, size_t num) const;
            SBlock GetChild(const String &tree, const String &name);
            SCBlock GetChild(const String &tree, const String &name) const;
            void RemoveChild(const String &tree, size_t num);
            void RemoveChild(const String &tree, const String &name);
            void RemoveChild(const String &tree, SBlock b);
            void RemoveChildren(const String &tree, const std::set<SBlock> &toremove);

            std::vector<String> GetTreeNames() const;
            bool HasTree(const String &tname) const;
            void RemoveTree(const String &tname);

            bool Append(const Path &fname);
            void Save(const Path &fname);
            void Save() { Save(GetFilename()); }

            SImageRGB GetRGB();
            SImageGray GetGray(bool create = true);
            SImageBW GetBW(bool create = true);
            SImageGradient GetGradient(bool create = true, double sigma = -1, size_t diffusemaxiter = 0, double diffusemaxdiv = std::numeric_limits<double>::max());
            void ReloadImage();
            void FlushAll(bool recursive = false);
            void FlushRGB(bool recursive = false);
            void FlushGray(bool recursive = false);
            void FlushBW(bool recursive = false);
            void FlushGradient(bool recursive = false);
            void SubstituteRGB(const SImageRGB &img);
            void SubstituteGray(const SImageGray &img);
            void SubstituteBW(const SImageBW &img);
            void SubstituteGradient(const SImageGradient &img);

            UImageIntGray ExtractCC(const String &tree);
        
            void FilterMinAnd(const String &tree, size_t minw, size_t minh);
            void FilterMinOr(const String &tree, size_t minw, size_t minh);
            void FilterMaxAnd(const String &tree, size_t maxw, size_t maxh);
            void FilterMaxOr(const String &tree, size_t maxw, size_t maxh);
            void FilterBorders(const String &tree, size_t margin);
            void FilterWidthRatio(const String &tree, double ratio);
            void FilterHeightRatio(const String &tree, double ratio);
            bool MergeChildren(const String &tree, double overlap, ImageIntGray *imap = nullptr);
            void MergeSiblings(const String &tree, size_t index1, size_t index2, ImageIntGray *imap = nullptr);
            void MergeSiblings(const String &tree, Block &sb1, Block &sb2, ImageIntGray *imap = nullptr);
            void GetTreeMeans(const String &tree, double *mwidth, double *mheight, double *marea) const;

#include <CRNBlockIterator.h>
            block_iterator BlockBegin(const String &tree);
            block_iterator BlockEnd(const String &tree);

            const_block_iterator BlockBegin(const String &tree) const;
            const_block_iterator BlockEnd(const String &tree) const;

            SVector GetTree(const String &name)
            {
                if (child->Find(name) == child->end()) return nullptr; 
                else return std::static_pointer_cast<Vector>(child->Get(name));
            }
            SCVector GetTree(const String &name) const
            {
                if (child->Find(name) == child->end()) return nullptr; 
                else return std::static_pointer_cast<const Vector>(child->Get(name));
            }

            void SortTree(const String &name, Direction direction);

            using pixel_iterator = Rect::iterator;
            pixel_iterator PixelBegin(const String &tree, size_t num) const;
            pixel_iterator PixelBegin(const SBlock &b) const;
            pixel_iterator PixelEnd(const String &tree, size_t num) const;
            pixel_iterator PixelEnd(const SBlock &b) const;

            class masked_pixel_iterator: public pixel_iterator
            {
                public:
                    masked_pixel_iterator() noexcept:pixel_iterator(),offsetx(0),offsety(0),value(0) {}
                    masked_pixel_iterator(const masked_pixel_iterator &it):
                        pixel_iterator(it),mask(it.mask),offsetx(it.offsetx),offsety(it.offsety),value(it.value) 
                    {
                        if (mask)
                            if (mask->At(pos.X - offsetx, pos.Y - offsety) != value)
                                operator++();
                    }
                    masked_pixel_iterator(const Rect &r, const SImageBW &ibw, int ox, int oy, pixel::BW val = pixel::BWBlack) noexcept:
                        pixel_iterator(r),mask(ibw),offsetx(ox),offsety(oy),value(val) 
                    {
                        if (mask->At(pos.X - offsetx, pos.Y - offsety) != value)
                            operator++();
                    }
                    virtual ~masked_pixel_iterator() override {}
                    masked_pixel_iterator& operator=(const masked_pixel_iterator &it) noexcept
                    {
                        pixel_iterator::operator=(it);
                        mask = it.mask;
                        value = it.value;
                        offsetx = it.offsetx;
                        offsety = it.offsety;
                        return *this; 
                    }
                    virtual const masked_pixel_iterator& operator++() noexcept override
                    { 
                        pixel_iterator::operator++(); 
                        while (valid) 
                        { 
                            if (mask->At(pos.X - offsetx, pos.Y - offsety) == value) 
                                break; 
                            pixel_iterator::operator++(); 
                        } 
                        return *this;
                    }
                private:
                    SCImageBW mask; 
                    int offsetx, offsety; 
                    pixel::BW value; 
            };
            masked_pixel_iterator MaskedPixelBegin(const String &tree, size_t num, pixel::BW mask_value = pixel::BWBlack);
            masked_pixel_iterator MaskedPixelEnd(const String &tree, size_t num, pixel::BW mask_value = pixel::BWBlack);
            masked_pixel_iterator MaskedPixelBegin(const SBlock &b, pixel::BW mask_value = pixel::BWBlack);
            masked_pixel_iterator MaskedPixelEnd(const SBlock &b, pixel::BW mask_value = pixel::BWBlack);

        private:
            Block(const SImage &src, const String &nam = U"");
            Block(const Path &ifname, const Path &xfname, const String &nam = U"");
            static SBlock create(const WBlock &par, const String &tree, const Rect &clip, const String &nam = U""); 
            Block(const WBlock &par, const String &tree, const Rect &clip, const String &nam = U""); 

            void addToXml(xml::Document &parent); 
            void addToXml(xml::Element &parent); 
            void addTreeFromXml(xml::Element &bnode); 
            void openImage(void); 
            void refreshSources();

            SMap child; 
            SVector getChildList(const String &name); 
            WBlock self; 
            WBlock parent; 
            String parenttree; 
            Path imagefilename; 
            bool image_is_open; 
            SImageRGB srcRGB; 
            SImageRGB get_srcRGB(void); 
            SImageGray srcGray; 
            SImageGray get_srcGray(void); 
            SImageBW srcBW; 
            SImageBW get_srcBW(void); 
            SImageGradient srcGradient; 
            SImageGradient get_srcGradient(void); 
            Rect bbox; 
            SImageRGB buffRGB; 
            SImageGray buffGray; 
            SImageBW buffBW; 
            SImageGradient buffGradient; 
            double grad_sigma; 
            size_t grad_diffusemaxiter; 
            double grad_diffusemaxdiv; 
    };
}
#endif