mine_server/server/ant.h

/**
 * 分站数据结构 site_list
 */
#ifndef _ANT_LIST_HPP_
#define _ANT_LIST_HPP_

#include <math.h>
#include <array>
#include <deque>
#include <tuple>
#include <time.h>
#include <sstream>
#include <memory>
#include <memory.h>
#include <algorithm>
#include <sstream>
#include "log.h"
#include "line.h"
#include "point.h"
#include "write-copy.h"
#include "net-service.h"
#include "common.h"
#include <boost/circular_buffer.hpp>

class client;
class area;
struct path
{
    std::array<line_v,2>	m_line;
    path()
    {
    }

    std::string to_str() const
    {
        std::stringstream ss;
        for(int i=0;i<2;i++)
        {
            ss<<"line:" <<m_line[i].to_string()<<"slope:"<<m_line[i][0].z<< " cos:"<<m_line[i].cos()<<" sin:"<<m_line[i].sin()<<" | ";
        }
        return ss.str();
    }
    bool valid() const
    {
        return !m_line[0].empty();
    }
    line_v & operator[](int i)
    {
        return m_line[i];
    }
    const line_v & operator[](int i) const
    {
        return m_line[i];
    }
};
//?
struct algo_config
{
    const char*desc;
    int min_msg_cnt;
    int best_msg_cnt;
    double min_wait_time;
    double max_wait_time;
};

// 基站覆盖范围信息
struct site_coverage_info{
	double m_distance;	// 距离
	std::string m_cid;	// 卡号
	uint64_t m_time;	// 时间

	site_coverage_info()
		: m_distance(0.0)
		, m_cid("")
		, m_time(0)
	{}
};
//
struct ant :point
{
    std::array<path,2> m_path;
    int m_id;
    double m_angle = 0;
	boost::circular_buffer<double> m_cache_poa;		// 缓存5个天线的相位差值

	ant()
	{
		m_cache_poa.set_capacity(5);
	}

    path & operator[](int i)
    {
        return m_path[i];
    }

    const path & operator[](int i) const
    {
        return m_path[i];
    }

    size_t size() const
    {
        return m_path.size();
    }

	void set_path(const std::vector<line_v>&v_line);
	void set_path(const std::vector<line_v>&v_line,std::vector<line_v>::const_iterator it);
    std::vector<point> getsol(const double &dist) const;

	bool phase_error();
};

struct site:point,std::enable_shared_from_this<site>
{
    static algo_config g_config[];
    int      m_algo;			// TOF:0, TDOA:1, PDOA:2
    int      m_num_dims;	    // 1维:1, 2维:2, 3维:3
    double  m_scale = 2.0;  // 地图比例尺
    point    m_position;
    //mutable double m_height=1.5;
	mutable double m_height = 0;
    std::array<ant,2> m_ant;
    mutable double m_ant_dist=0;
    mutable double m_ant_dist_sum_new=0;
    mutable int m_ant_dist_cnt_new=0;
	bool m_need_count = true;
    ///分站位置 READER_TYPE_ID, 井上分站，井下分站
    int m_reader_type_id = 0;
    int m_map_id = 0;
    int m_area_id = 0;
    // 设备类型，分站、通信分站、交通灯等
    int m_device_type_id=0;
	// 是否为网络设备，0为can设备，1为网络设备
	int m_net_device_status;
    
    //pdoa
    double m_pdoa_offset = 0.0;     // pdoa分站天线相位偏移量,90度的偏移值
    int m_pdoa_direction = 0;       // pdoa分站天线1朝向
    std::shared_ptr<client> m_clt = nullptr;
    std::shared_ptr<area> m_area = nullptr;

	time_t m_time;
	time_t m_loc_time = time(0);	// 基站定位时间
//  time_t m_rec_time;              // 接收数据的时间
//  time_t m_lost_time;		        // 丢失时间
//  time_t m_last_send_time;	    // 最后向前端发送时间

    int m_id{-1};
//  int  m_tick_count;			    // 分站发生消息的计数器

//  unsigned char m_reader_dir;		// 分站方向，对于大小分站适用
//  unsigned char m_relay_counts;		// 大小分站经过中继数
    bool m_power_check_enable=false;//该分站是否启用交流掉电检测功能(告警功能)
    bool m_power_ac_down=false;     //false=交流电供电状态
    bool m_path_empty;

	std::array<int,32>	m_timeoff_count;
	std::array<site_coverage_info, 2> m_coverage;	// 0为正向参数，1为负向参数
	int  m_package_count=0;
    int  m_special = 0;
	int  m_down_stream_idx = 0;
	double m_tof_dist_offset = 0.0;

    site(int id=-1);

	time_t m_site_time=0;		//分站报文中的时间
	void set_site_time(time_t site_time)
	{
		m_site_time=site_time;
	}

	time_t last_site_time()const
	{
		return m_site_time;
	}

    int index()const;
    const algo_config&config()const;
    int id()const
    {
        return m_id;
	}
    void set_client(const std::shared_ptr<client>& clt)
    {
		if(m_clt != clt)
			m_clt = clt;
		m_time = time(0);
    }

    std::shared_ptr<client> get_client()
    {
        return m_clt;
    }

    bool is_up_site()
    {
        return READER_TYPE_ID_UP == m_reader_type_id;
    }
    bool is_abnormal_site()
    {
        bool f=false;
        double d=ant_dist();
        if(!is_up_site() &&(d<1e-5 && d>-1e-5) )
            f=true;
        return f;
    }
    void create_area();
    const std::shared_ptr<area> &get_area()const{return m_area;}
    void clear_event();
    point get_dstp(const point pt) const
    {
        point tmp;
        for(const auto & p : m_ant[0].m_path){
            for(int i=0;i<2;i++){
                if(!p[i].empty()){
                    if(p[i].contain(pt,0.01)){
                        tmp = p[i][0];
                    }
                }
            }
        }
        if(tmp.empty())
            log_info("(%f,%f) can't find the point at [%d]",pt.x,pt.y,m_id);
        return tmp;
    }

    void count_ant_dist(double dist_tof1, double dist_tof2)const
    {
        //if(dist_tof1<10 || dist_tof2<10)
        //    return;
        double dist = fabs(dist_tof1 - dist_tof2);
        if(dist>5)
            return;
        m_ant_dist_sum_new += dist;
        m_ant_dist_cnt_new++;
		if (m_need_count)
		{
			m_ant_dist = m_ant_dist_sum_new / m_ant_dist_cnt_new;
		}
		
        if(m_ant_dist_cnt_new >= 2500)
        {
            m_ant_dist = m_ant_dist_sum_new / m_ant_dist_cnt_new;
            m_ant_dist_sum_new = 0;
            m_ant_dist_cnt_new = 0;
        }
    }

    double ant_dist()const
    {
        return m_ant[0].dist(m_ant[1]);
    }

    bool is_path_empty()const
    {
        return m_path_empty;
    }

    bool have_valid_path()const
    {
        return m_id != -1 && ant_dist() > 0.1;
    }

    std::string to_string()const
    {
        std::stringstream ss;
        ss<<"site_id:"<<m_id<<"x:"<<x<<" y: "<<y<<" scale:"<<m_scale;
        for(const auto&a:m_ant)
        {
            ss<<"<";
            for(const auto&p:a.m_path)
            {
                ss<<"{"<<p.to_str()<<"}";
            }
            ss<<">";
        }
        return ss.str();
    }

    const point&path(int i)const
    {
        static point p;
        if(i>=(int)m_ant[0].m_path.size())
            return p ;
        return m_ant[0].m_path[i].m_line[0][1];
    }

	void set_path(const std::vector<line_v>&v_line);
    std::vector<point> solving(int ant_id, double dist)const
    {
        const ant &a = m_ant[ant_id];
        if(dist < 50 && dist > 0)
        {
            if(dist < m_height)
            {
                m_height = dist;
                dist = 0;
            }
            else
            {
                dist = sqrt(dist*dist - m_height*m_height);
            }
        }
        return std::move(a.getsol(dist));
    }

    std::vector<point> solving_pdoa(const int& ant_id, double dist)const
    {
        const ant& a = m_ant[ant_id];
        //logn_info(3, "[pdoa] solving_pdoa, dist=%.4f, a.x=%.4f, a.y=%.4f", dist, a.x, a.y);
        return std::move(a.getsol(dist));
    }

    ant&operator[](int i)
    {
        return m_ant[i];
    }

    const ant&operator[](int i) const
    {
        return m_ant[i];
    }

    void set_ex()
    {
        if(-1 == m_id)
        {
            return;
        }

        if(m_ant[0]==m_ant[1])
        {
            log_warn("%d分站天线坐标相等.", m_id);
        }

        set( (m_ant[0].x+m_ant[1].x)/2,(m_ant[0].y+m_ant[1].y)/2);
    }

    void delete_antenna(int antidx)
    {
        m_ant[antidx].set(point(0,0));
    }

/*

	处理分站供电状态，交流供电时，ac_down=false，直流供电时,ac_down=true

	目前只有大分站实现了这个功能，并且井下安装时是否接入了该电信号也不确定
	，所以需要有张表定义某个ID是否需要告警

*/

	void on_power_status(bool ac_down);     //电源状态
    void set_algo(int _algo)
    {
        m_algo = _algo;
    }

    double get_site_dist(const int& sid);

	void push_poa(const double& poa1, const double& poa2)
	{
		m_ant[0].m_cache_poa.push_back(poa1);
		m_ant[1].m_cache_poa.push_back(poa2);
	}
};

struct visit_site_status:visitor<std::shared_ptr<site>>
{
	bool visit(std::shared_ptr<site> s);
};

struct sit_list:single_base<sit_list,int,std::shared_ptr<site>>
{
    void load(const std::string &id)
    {
        int sid=-1;
        if(!id.empty())sid=std::stoi(id);
        read_sit_list(sid);
        read_ant_path(sid);
    }
    ///id=-1为初始化所有
    void load_from_db(const std::string&ids="")
    {
        init_site(ids);
        load(ids);
    }
    void read_sit_list(int id=-1);
    void read_ant_path(int id=-1);
    void init_site(const std::string &ids="");
};

struct sit_list_v :single_base<sit_list_v, int, std::shared_ptr<site>>
{
	void load(const std::string &id)
	{
		int sid = -1;
		if (!id.empty())sid = std::stoi(id);
		read_sit_list(sid);
		read_ant_path(sid);
	}
	///id=-1为初始化所有
	void load_from_db(const std::string&ids = "")
	{
		init_site(ids);
		load(ids);
	}
	void read_sit_list(int id = -1);
	void read_ant_path(int id = -1);
	void init_site(const std::string &ids = "");
};
#endif