CCaliperLineFinderComp.h

Go to the documentation of this file.

/********************************************************************************
**  This file is part of the ICF Framework. Copyright (C) Witold Gantzke & Kirill Lepskiy
**  ICF Framework may be used under the terms of the LGPL License v. 2.1 by the Free Software Foundation.
********************************************************************************/
 
#pragma once
 
 
// ICF includes
#include <ilog/IMessageConsumer.h>
#include <i2d/CLine2d.h>
#include <i2d/CParallelogram.h>
#include <i2d/CPolypoint.h>
#include <i2d/ICalibration2dProvider.h>
 
#include <iproc/TSyncProcessorCompBase.h>
#include <iipr/IImageToFeatureProcessor.h>
#include <iipr/IFeaturesProvider.h>
#include <iipr/IFeatureToImageMapper.h>
#include <iipr/ICaliperFinderParams.h>
#include <iipr/TWeightedFeatureWrap.h>
#include <iipr/CCaliperFinderBase.h>
 
 
namespace iipr
{
 
 
class CCaliperLineFinderComp:
        public iproc::TSyncProcessorCompBase<IImageToFeatureProcessor>,
        protected CCaliperFinderBase
{
public:
    typedef iproc::TSyncProcessorCompBase<IImageToFeatureProcessor> BaseClass;
 
    I_BEGIN_COMPONENT(CCaliperLineFinderComp);
        I_REGISTER_INTERFACE(IImageToFeatureProcessor);
        I_REGISTER_INTERFACE(iproc::IProcessor);
        I_ASSIGN(m_slaveProcessorCompPtr, "SlaveEdgeProcessor", "Slave edge finder processor converting image to list of found edges", true, "SlaveEdgeProcessor");
        I_ASSIGN(m_featuresMapperCompPtr, "FeaturesMapper", "Calculate position from caliper extracted features", true, "FeaturesMapper");
        I_ASSIGN(m_resultCalibrationCompPtr, "ResultCalibration", "Calibration should be used for result", false, "ResultCalibration");
        I_ASSIGN(m_aoiParamIdAttrPtr, "AoiParamId", "ID of area of interest in parameter set", true, "AoiParams");
        I_ASSIGN(m_finderParamsIdAttrPtr, "CaliperFinderParamsId", "ID of caliper finder parameters in parameter set (iipr::ICaliperFinderParams)", true, "CaliperFinderParams");
        I_ASSIGN(m_slaveLineIdAttrPtr, "SlaveLineId", "ID of line parameter added by this processor to parameter set for slave edge processor", true, "LineParam");
        I_ASSIGN(m_searchParallelLinesAttrPtr, "SearchParallelLines", "If it is true, parallel lines will be searched", true, false);
        I_ASSIGN(m_sendUsedPointsToTempAttrPtr, "SendUsedPointsToTemp", "If true, the used point positions will be send to temporary results", true, false);
        I_ASSIGN(m_sendLinesToTempAttrPtr, "SendLinesToTemp", "If true, the caliper lines will be send to temporary results", true, false);
        I_ASSIGN(m_resultConsumerCompPtr, "ResultConsumer", "Consumer of result messages with geometrical layout", false, "ResultConsumer");
        I_ASSIGN(m_tempConsumerCompPtr, "TempConsumer", "Consumer of temporary result messages", false, "TempResultsConsumer");
    I_END_COMPONENT;
 
    CCaliperLineFinderComp();
 
    // reimplemented (iipr::IImageToFeatureProcessor)
    virtual iproc::CTaskState DoExtractFeatures(
            const iprm::IParamsSet* paramsPtr,
            const iimg::IBitmap& image,
            IFeaturesConsumer& results,
            iproc::IProgressManager* progressManagerPtr = nullptr) override;
 
    // reimplemented (iproc::IProcessor)
    virtual iproc::CTaskState DoProcessing(
            const iprm::IParamsSet* paramsPtr,
            const istd::IPolymorphic* inputPtr,
            istd::IChangeable* outputPtr,
            bool allowAsync = false,
            iproc::IProgressManager* progressManagerPtr = nullptr) override;
 
    // static methods
    static double CalculateLine(
            const i2d::CVector2d& direction,
            double minOutliersDist,
            Rays& rays,
            i2d::CLine2d& result);
    static double CalculateParallelLines(
            const i2d::CVector2d& direction,
            double minOutliersDist,
            Rays& inRays,
            Rays& outRays,
            i2d::CParallelogram& result);
 
protected:
    double DoFindSingleLine(const iprm::IParamsSet* paramsPtr, const iimg::IBitmap& image, i2d::CLine2d& result);
    double DoFindParallelLines(const iprm::IParamsSet* paramsPtr, const iimg::IBitmap& image, i2d::CParallelogram& result);
 
    bool CalcRays(const iprm::IParamsSet* paramsPtr, const iimg::IBitmap& image, Rays& inRays, Rays& outRays, double& minOutlierDist);
    void AddIntermediateResults(const Rays& outRays, const QString& name);
 
    // reimplemented (icomp::CComponentBase)
    void OnComponentCreated() override;
 
private:
    I_REF(iproc::IProcessor, m_slaveProcessorCompPtr);
    I_REF(iipr::IFeatureToImageMapper, m_featuresMapperCompPtr);
    I_REF(i2d::ICalibration2d, m_resultCalibrationCompPtr);
    I_ATTR(QByteArray, m_aoiParamIdAttrPtr);
    I_ATTR(QByteArray, m_slaveLineIdAttrPtr);
    I_ATTR(QByteArray, m_finderParamsIdAttrPtr);
    I_ATTR(bool, m_searchParallelLinesAttrPtr);
    I_ATTR(bool, m_sendUsedPointsToTempAttrPtr);
    I_ATTR(bool, m_sendLinesToTempAttrPtr);
    I_REF(ilog::IMessageConsumer, m_resultConsumerCompPtr);
    I_REF(ilog::IMessageConsumer, m_tempConsumerCompPtr);
};
 
 
} // namespace iipr