CRNDifferential.h

Go to the documentation of this file.

/* Copyright 2006-2016 Yann LEYDIER, CoReNum, INSA-Lyon, 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: CRNDifferential.h
 * \author Yann LEYDIER
 */

#ifndef CRNDIFFERENTIAL_HEADER
#define CRNDIFFERENTIAL_HEADER

#include <CRNImage/CRNImageGradient.h>
#include <CRNImage/CRNImageGray.h>
#include <mutex>

namespace crn
{
    class Differential;
    CRN_ALIAS_SMART_PTR(Differential)
}
namespace crn
{
    /****************************************************************************/
    class Differential
    {
        public:
            enum class RGBProjection { ABSMAX, SUM };
            static Differential NewGaussian(const ImageRGB &src, RGBProjection proj, double sigma);
            static Differential NewHalfDiff(const ImageRGB &src, RGBProjection proj);
            static Differential NewHalfDiffAbsMax(const ImageRGB &src, RGBProjection proj);
            static Differential NewHalfDiffAbsMin(const ImageRGB &src, RGBProjection proj);

            template<typename T> static Differential NewGaussian(const Image<T> &src, double sigma)
            { auto i = ImageDoubleGray(src); return NewGaussian(i, sigma); }
            template<typename T> static Differential NewHalfDiff(const Image<T> &src)
            { auto i = ImageDoubleGray(src); return NewHalfDiff(i); }
            template<typename T> static Differential NewHalfDiffAbsMax(const Image<T> &src)
            { auto i = ImageDoubleGray(src); return NewHalfDiffAbsMax(i); }
            template<typename T> static Differential NewHalfDiffAbsMin(const Image<T> &src)
            { auto i = ImageDoubleGray(src); return NewHalfDiffAbsMin(i); }

            static Differential NewGaussian(const ImageDoubleGray &src, double sigma);
            static Differential NewHalfDiff(const ImageDoubleGray &src);
            static Differential NewHalfDiffAbsMax(const ImageDoubleGray &src);
            static Differential NewHalfDiffAbsMin(const ImageDoubleGray &src);

            ~Differential() = default;

            Differential(const Differential &) = delete;
            Differential(Differential &&) = default;
            Differential& operator=(const Differential &) = delete;
            Differential& operator=(Differential &&) = default;

            ImageDoubleGray& GetLx() noexcept { return lx; }
            const ImageDoubleGray& GetLx() const { return lx; }
            ImageDoubleGray& GetLy() noexcept { return ly; }
            const ImageDoubleGray& GetLy() const { return ly; }
            ImageDoubleGray& GetLx2Ly2() noexcept { return lx2ly2; }
            const ImageDoubleGray& GetLx2Ly2() const { return lx2ly2; }
            const ImageDoubleGray& GetLxx();
            const ImageDoubleGray& GetLxy();
            const ImageDoubleGray& GetLyx();
            const ImageDoubleGray& GetLyy();

            void Diffuse(size_t maxiter, double maxdiv = std::numeric_limits<double>::max());

            ImageDoubleGray MakeLw();
            ImageDoubleGray MakeLvv();
            ImageDoubleGray MakeLww();
            ImageDoubleGray MakeLvw();
            
            ImageDoubleGray MakeKappa1();
            ImageDoubleGray MakeKappa2();
            ImageDoubleGray MakeHessianCorner(double s = 0.1);
            ImageDoubleGray MakeLaplacian();
            ImageDoubleGray MakeIsophoteCurvature();
            ImageDoubleGray MakeFlowlineCurvature();
            ImageDoubleGray MakeEdge();
            ImageDoubleGray MakeCorner();
            ImageDoubleGray MakeGaussianCurvature();
            ImageGradient MakeImageGradient();
            ImageDoubleGray MakeGradientModule();
            ImageGray MakeGradientCurvature();
            ImageDoubleGray MakeCanny();
            ImageDoubleGray MakeDivergence();

            double AutoThreshold();
            double GetThreshold() const noexcept { return thres; }
            void SetThreshold(double d) noexcept { thres = d; }
            bool IsSignificant(size_t i) const noexcept { return GetLx2Ly2().At(i) > thres; }
            bool IsSignificant(size_t x, size_t y) const noexcept { return GetLx2Ly2().At(x, y) > thres; }
            template<typename T> void FillNonSignificant(Image<T> &img, T val = T(0)) const
            {
                if ((img.GetWidth() != lx2ly2.GetWidth()) || (img.GetHeight() != lx2ly2.GetHeight()))
                    throw ExceptionDimension("The image does not have the same dimensions as the differential.");
                for (auto tmp : Range(img))
                {
                    if (!IsSignificant(tmp))
                        img.At(tmp) = val;
                }
            }

        private:
            Differential(ImageGray &&src, ImageDoubleGray &&xdiff, ImageDoubleGray &&ydiff, ImageDoubleGray &&xxdiff, ImageDoubleGray &&yydiff);
            Differential(ImageGray &&src, ImageDoubleGray &&xdiff, ImageDoubleGray &&ydiff);

            void updateLx2ly2();

            ImageGray srcigray; 
            ImageDoubleGray lx; 
            ImageDoubleGray ly; 
            ImageDoubleGray lxx; 
            ImageDoubleGray lxy; 
            ImageDoubleGray lyx; 
            ImageDoubleGray lyy; 
            ImageDoubleGray lx2ly2; 
            double thres; 
            std::unique_ptr<std::mutex> lazydata; 
    };
}
#endif