NLDetectorBuilder.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-2024 German Aerospace Center (DLR) and others.
// This program and the accompanying materials are made available under the
// terms of the Eclipse Public License 2.0 which is available at
// https://www.eclipse.org/legal/epl-2.0/
// This Source Code may also be made available under the following Secondary
// Licenses when the conditions for such availability set forth in the Eclipse
// Public License 2.0 are satisfied: GNU General Public License, version 2
// or later which is available at
// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
/****************************************************************************/
// Builds detectors for microsim
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <string>
#include <microsim/output/MSCrossSection.h>
#include <microsim/traffic_lights/MSTLLogicControl.h>
#include <microsim/output/MSE2Collector.h>
// #include <microsim/output/MSMultiLaneE2Collector.h>
 
// ===========================================================================
// class declarations
// ===========================================================================
class MSDetectorFileOutput;
class MSLane;
class MSEdge;
 
class MEInductLoop;
class MESegment;
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class NLDetectorBuilder {
public:
    NLDetectorBuilder(MSNet& net);
 
 
    virtual ~NLDetectorBuilder();
 
 
 
    Parameterised* buildInductLoop(const std::string& id,
                                   const std::string& lane, double pos, double length, SUMOTime splInterval,
                                   const std::string& device, bool friendlyPos,
                                   const std::string name, const std::string& vTypes, const std::string& nextEdges, int detectPersons);
 
 
    Parameterised* buildInstantInductLoop(const std::string& id,
                                          const std::string& lane, double pos,
                                          const std::string& device, bool friendlyPos,
                                          const std::string name, const std::string& vTypes,
                                          const std::string& nextEdges);
 
 
    Parameterised* buildE2Detector(const std::string& id, MSLane* lane, double pos, double endPos, double length,
                                   const std::string& device, SUMOTime frequency,
                                   SUMOTime haltingTimeThreshold, double haltingSpeedThreshold, double jamDistThreshold,
                                   const std::string name, const std::string& vTypes,
                                   const std::string& nextEdges,
                                   int detectPersons, bool friendlyPos, bool showDetector,
                                   MSTLLogicControl::TLSLogicVariants* tlls = 0, MSLane* toLane = 0);
 
    Parameterised* buildE2Detector(const std::string& id, std::vector<MSLane*> lanes, double pos, double endPos,
                                   const std::string& device, SUMOTime frequency,
                                   SUMOTime haltingTimeThreshold, double haltingSpeedThreshold, double jamDistThreshold,
                                   const std::string name, const std::string& vTypes,
                                   const std::string& nextEdges,
                                   int detectPersons, bool friendlyPos, bool showDetector,
                                   MSTLLogicControl::TLSLogicVariants* tlls = 0, MSLane* toLane = 0);
 
 
    Parameterised* beginE3Detector(const std::string& id, const std::string& device, SUMOTime splInterval,
                                   double haltingSpeedThreshold, SUMOTime haltingTimeThreshold,
                                   const std::string name, const std::string& vTypes,
                                   const std::string& nextEdges,
                                   int detectPersons, bool openEntry, bool expectArrival);
 
 
    void addE3Entry(const std::string& lane, double pos, bool friendlyPos);
 
 
    void addE3Exit(const std::string& lane, double pos, bool friendlyPos);
 
 
    void endE3Detector();
 
 
    std::string getCurrentE3ID() const;
 
 
    void buildVTypeProbe(const std::string& id,
                         const std::string& vtype, SUMOTime frequency,
                         const std::string& device);
 
 
    void buildRouteProbe(const std::string& id, const std::string& edge,
                         SUMOTime frequency, SUMOTime begin,
                         const std::string& device,
                         const std::string& vTypes);
 
 
 
 
    virtual MSDetectorFileOutput* createInductLoop(const std::string& id,
            MSLane* lane, double pos,
            double length,
            const std::string name, const std::string& vTypes,
            const std::string& nextEdges,
            int detectPersons,
            bool show);
 
 
    virtual MSDetectorFileOutput* createInstantInductLoop(const std::string& id,
            MSLane* lane, double pos, const std::string& od,
            const std::string name, const std::string& vTypes,
            const std::string& nextEdges);
 
 
    virtual MSE2Collector* createE2Detector(const std::string& id,
                                            DetectorUsage usage, MSLane* lane, double pos, double endPos, double length,
                                            SUMOTime haltingTimeThreshold, double haltingSpeedThreshold, double jamDistThreshold,
                                            const std::string name, const std::string& vTypes,
                                            const std::string& nextEdges,
                                            int detectPersons, bool showDetector);
 
    virtual MSE2Collector* createE2Detector(const std::string& id,
                                            DetectorUsage usage, std::vector<MSLane*> lanes, double pos, double endPos,
                                            SUMOTime haltingTimeThreshold, double haltingSpeedThreshold, double jamDistThreshold,
                                            const std::string name, const std::string& vTypes,
                                            const std::string& nextEdges,
                                            int detectPersons, bool showDetector);
 
    virtual MSDetectorFileOutput* createE3Detector(const std::string& id,
            const CrossSectionVector& entries, const CrossSectionVector& exits,
            double haltingSpeedThreshold, SUMOTime haltingTimeThreshold,
            const std::string name, const std::string& vTypes,
            const std::string& nextEdges,
            int detectPersons, bool openEntry, bool expectArrival);
 
 
    void createEdgeLaneMeanData(const std::string& id, SUMOTime frequency,
                                SUMOTime begin, SUMOTime end, const std::string& type,
                                const bool useLanes, const bool withEmpty, const bool printDefaults,
                                const bool withInternal, const bool trackVehicles, const int detectPersons,
                                const double maxTravelTime, const double minSamples,
                                const double haltSpeed, const std::string& vTypes,
                                const std::string& writeAttributes,
                                std::vector<MSEdge*> edges,
                                bool aggregate,
                                const std::string& device);
 
 
protected:
    class E3DetectorDefinition : public Parameterised {
    public:
        E3DetectorDefinition(const std::string& id,
                             const std::string& device, double haltingSpeedThreshold,
                             SUMOTime haltingTimeThreshold, SUMOTime splInterval,
                             const std::string name, const std::string& vTypes,
                             const std::string& nextEdges,
                             int detectPersons, bool openEntry, bool expectArrival);
 
        virtual ~E3DetectorDefinition();
 
        const std::string myID;
        const std::string myDevice;
        double myHaltingSpeedThreshold;
        SUMOTime myHaltingTimeThreshold;
        CrossSectionVector myEntries;
        CrossSectionVector myExits;
        SUMOTime mySampleInterval;
        std::string myName;
        const std::string myVehicleTypes;
        const std::string myNextEdges;
        int myDetectPersons;
        bool myOpenEntry;
        bool myExpectArrival;
 
    private:
        E3DetectorDefinition(const E3DetectorDefinition&);
 
        E3DetectorDefinition& operator=(const E3DetectorDefinition&);
 
    };
 
 
protected:
    double getPositionChecking(double pos, MSLane* lane, bool friendlyPos,
                               SumoXMLTag tag,
                               const std::string& detid);
 
 
 
    MSEdge* getEdgeChecking(const std::string& edgeID, SumoXMLTag type,
                            const std::string& detid);
 
public:
    MSLane* getLaneChecking(const std::string& laneID, SumoXMLTag type,
                            const std::string& detid);
 
protected:
    void checkSampleInterval(SUMOTime splInterval, SumoXMLTag type, const std::string& id);
 
 
protected:
    MSNet& myNet;
 
 
private:
    E3DetectorDefinition* myE3Definition;
 
 
private:
    NLDetectorBuilder(const NLDetectorBuilder&);
 
    NLDetectorBuilder& operator=(const NLDetectorBuilder&);
 
};