完善区域框架逻辑

area.cpp

@@ -20,68 +20,79 @@ single_base<area_list, int, std::shared_ptr<area>>::m_instance=std::make_shared<
 
 struct underground_area:area
 {
-    underground_area(int limit_count_person, int limit_time_person,double scale,int32_t mapid)
-        :area(-1,limit_count_person,limit_time_person,scale,mapid,(1<<1)|(1<<2)|(1<<3)|(1<<4))
+    underground_area(int id,int limit_count_person, int limit_time_person,double scale,int32_t mapid,int32_t type)
+        :area(id,limit_count_person,limit_time_person,scale,mapid,type)
 	{
-		m_area_business_list=area_business::get_instance_list(m_area_type);
-	}
-
-	void db_load_card_count()
-	{
-	
 	}
-
-    virtual bool in_area(const std::shared_ptr<site>&s, const point & p)
-	{
-		//根据s的地面、地下属性判断
-		return false;
-	}
-};
-
-struct ground_area:area
-{
-    virtual bool in_area(const std::shared_ptr<site>&s, const point & p)
+    virtual bool in_area(const std::shared_ptr<site>&s,const std::shared_ptr<card_location_base>&c, const point & p,int &sarid)
 	{
-		//根据s的地面、地下属性判断
-		return false;
+		bool f =false;
+		int id = c->get_area();
+		if(id!=-1)
+		  f=true;
+		return f;
 	}
 };
 
 struct special_area:area
 {
-    virtual bool in_area(const std::shared_ptr<site>&s, const point & p)
+    special_area(int id,int limit_count_person, int limit_time_person,double scale,int32_t mapid,int32_t type)
+        :area(id,limit_count_person,limit_time_person,scale,mapid,type)
+	{}
+    virtual bool in_area(const std::shared_ptr<site>&s,const std::shared_ptr<card_location_base>&c, const point & p,int &sarid)
 	{
-		return false;
+		bool f=false;
+		int id = c->get_area();
+		if(id == m_id)
+		{
+		  f=true;
+		  sarid=m_id;
+		}
+		return f;
 	}
 };
 
-void area::on_hover(std::shared_ptr<area_hover>&a,std::shared_ptr<card_location_base>&c)
+area::area(int id,int limit_count_person, int limit_time_person,double scale,int32_t mapid,int32_t type)
+     :m_id(id)
+     ,m_area_type(type)
+     ,m_limit_person_second(limit_time_person)
+     ,m_limit_person_count(limit_count_person)
+     ,m_scale(scale)
+     ,m_mapid(mapid)
+     ,m_person_count(0)
+     ,m_vehicle_count(0)
+    {
+		m_area_business_list=area_business::get_instance_list(m_area_type);
+    }
+
+
+void area::on_hover(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c)
 {
- 	for(auto i:m_area_business_list)
+ 	for(const auto &i:m_area_business_list)
 	{
 		i->on_hover(a,c,a->get_business_data(i->area_business_type()));
 	}
 }
 
-void area::on_enter(std::shared_ptr<area_hover>&a,std::shared_ptr<card_location_base>&c)
+void area::on_enter(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c)
 {
 	log_info("on_enter..%d  areaId:%d",c->m_id,m_id);
- 	for(auto i:m_area_business_list)
+ 	for(const auto &i:m_area_business_list)
 	{
 		i->on_enter(a,c,a->get_business_data(i->area_business_type()));
 	}
 }
 
-void area::on_leave(std::shared_ptr<area_hover>&a,std::shared_ptr<card_location_base>&c)
+void area::on_leave(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c)
 {
 	log_info("on_leave..%d  areaId:%d",c->m_id,m_id);
- 	for(auto i:m_area_business_list)
+ 	for(const auto &i:m_area_business_list)
 	{
 		i->on_leave(a,c,a->get_business_data(i->area_business_type()));
 	}
 }
 
-bool area::in_area(const std::shared_ptr<site>&s, const point & p)
+bool area::in_area(const std::shared_ptr<site>&s,const std::shared_ptr<card_location_base>&c, const point & p,int & sarid)
 {
 	if(m_bound.empty())
 	  return false;
@@ -129,8 +140,6 @@ void area_list::init_monkeycar_area(int id)
         sql.append(" AND a.area_id=");
         sql.append(std::to_string(id));
         sql.append(";");
-
-        std_debug("基础数据 monkeycar area 增加或修改区域 sql=%s", sql.c_str());
         log_info("基础数据 monkeycar area 增加或修改区域 sql=%s", sql.c_str());
     }
 
@@ -190,10 +199,8 @@ void area_list::init_monkeycar_area(int id)
             std::shared_ptr<db_area>  da = std::make_shared<db_area>();
             da->m_default_speed = monkeycar_speed;
             da->m_point = init_path(monkeycar_coor);
-
-            std::shared_ptr<area> ap = std::make_shared<monkey_area>(da,area_id,over_count_person, over_time_person,scale,map_id,area_type_id);
-			//初始化区域逻辑
-			ap->m_area_business_list=std::move(area_business::get_instance_list(b_type));
+            std::shared_ptr<area> ap = std::make_shared<monkey_area>(da,area_id,over_count_person, over_time_person,scale,map_id,b_type);
+            ap->update(over_count_person, over_time_person,scale,map_id,area_type_id, over_count_vehicle,over_time_vehicle);
 
             ap->m_bound=init_path(path);
             for(const auto &p : ap->m_bound)
@@ -209,13 +216,11 @@ void area_list::init_monkeycar_area(int id)
             std::shared_ptr<db_area>  da = std::make_shared<db_area>();
             da->m_default_speed = monkeycar_speed;
             da->m_point = init_path(monkeycar_coor);
-            std::shared_ptr<area> ap = area_list::instance()->get(id);
-			if(!ap)
-			{
-				ap = std::make_shared<monkey_area>(da,area_id,over_count_person, over_time_person,scale,map_id,area_type_id);
-				area_list::instance()->add(id, ap);
-			}
-			ap->m_area_business_list=std::move(area_business::get_instance_list(b_type));
+			std::shared_ptr<area> ap = std::make_shared<monkey_area>(da,area_id,over_count_person, over_time_person,scale,map_id,b_type);
+			if(auto area_=area_list::instance()->get(id))
+				area_=ap;
+			else
+				area_list::instance()->add(area_id,ap);
 
             ap->m_bound=init_path(path);
             ap->update(over_count_person, over_time_person,scale,map_id,area_type_id, over_count_vehicle,over_time_vehicle);
@@ -238,6 +243,22 @@ void area_list::init_monkeycar_area(int id)
     }
 }
 
+std::shared_ptr<area>  area_list::create(int type,int id,int limit_count_person, int limit_time_person,double scale,int32_t mapid,int32_t b_type) 
+{
+	if(type==AREA_TYPE_FORBIDDEN)	
+	{
+		return std::make_shared<special_area>(id,limit_count_person,limit_time_person,scale,mapid,b_type);
+	}
+	else if(type == AREA_TYPE_DOWNMINE)
+	{
+		return std::make_shared<underground_area>(id,limit_count_person,limit_time_person,scale,mapid,b_type);
+
+	}
+	else
+	{
+		return std::make_shared<area>(id,limit_count_person,limit_time_person,scale,mapid,b_type);
+	}
+}
 void area_list::init_from_db(int id/*=-1*/)
 {
     std::string sql = "SELECT a.area_id, a.name, a.map_id, a.area_type_id, a.path,b.scale, \
@@ -245,7 +266,7 @@ void area_list::init_from_db(int id/*=-1*/)
             over_speed_vehicle, is_attendance,business_type \
             FROM dat_area a,dat_map b\
             where a.map_id = b.map_id and  area_id not in \
-            (select monkeycar_base_info_id from dat_monkeycar_base_info)";
+			  (select monkeycar_base_info_id from dat_monkeycar_base_info)";
 
     if(-1 == id)
     {
@@ -307,18 +328,13 @@ void area_list::init_from_db(int id/*=-1*/)
 
         if(-1 == id)
         {
-            std::shared_ptr<area> ap = std::make_shared<area>(area_id,over_count_person,over_time_person,
-                                                              scale,map_id,area_type_id);
-
+            std::shared_ptr<area> ap = create(area_type_id,area_id,over_count_person,over_time_person, scale,map_id,b_type);
             ap->m_limit_vehicle_second = over_time_vehicle;
             ap->m_limit_vehicle_count = over_count_vehicle;
 
             ap->m_bound=init_path(path);
             for(const auto &p : ap->m_bound)
               log_info("point:area_id:%d--x:%.2f,y:%.2f",area_id,p.x,p.y);
-			
-			ap->m_area_business_list=std::move(area_business::get_instance_list(b_type));
-
             map.insert({area_id,ap});
 
 //            CheckAreaType(ap,area_type_id,0);
@@ -328,12 +344,11 @@ void area_list::init_from_db(int id/*=-1*/)
             auto tmp_ptr = area_list::instance()->get(id);
             if(!tmp_ptr)
             {
-                tmp_ptr= std::make_shared<area>(area_id,over_count_person,over_time_person,scale,map_id,area_type_id);
+				tmp_ptr = create(area_type_id,area_id,over_count_person,over_time_person, scale,map_id,b_type);
                 area_list::instance()->add(id, tmp_ptr);
             }
             tmp_ptr->update(over_count_person, over_time_person,scale,map_id,area_type_id, over_count_vehicle,over_time_vehicle);
             tmp_ptr->m_bound=init_path(path);
-			tmp_ptr->m_area_business_list=std::move(area_business::get_instance_list(b_type));
             for(const auto &p : tmp_ptr->m_bound)
                 log_info("point:area_id:%d--x:%.2f,y:%.2f",area_id,p.x,p.y);
 //               CheckAreaType(tmp_ptr,area_type_id,tmp_ptr->m_area_type);
@@ -349,8 +364,8 @@ void area_list::init_from_db(int id/*=-1*/)
     {
         log_info( "init_area. The record count=%d\n", nCount );
         area_list::instance()->add(map);
-        init_monkeycar_area();
     }
+    init_monkeycar_area(id);
 }
 
 
@@ -455,34 +470,36 @@ std::vector<point> area_list::init_path(std::string &str)
 	return std::move(vp);
 }
 
-std::vector<std::shared_ptr<area>> area_list::get_area(const std::shared_ptr<site> s,const point&pt)
+std::vector<std::shared_ptr<area>> area_list::get_area(const std::shared_ptr<site> s,const std::shared_ptr<card_location_base> &c,const point&pt,int & sarid)
 {
 	std::vector<std::shared_ptr<area>> ret;
 		
 	auto map = area_list::instance()->m_map;
 
 	for(const auto &a:map)
-		if(a.second->in_area(s, pt))
+		if(a.second->in_area(s,c,pt,sarid))
 			ret.push_back(a.second);
 	//区域覆盖不完全地图，很多车辆人行驶在地图外，如何确认.
 	return std::move(ret);
 }
 
-void area_tool::on_point(const std::shared_ptr<site>&s,std::shared_ptr<card_location_base> c,const point&pt)
+void area_tool::on_point(const std::shared_ptr<site>&s,const std::shared_ptr<card_location_base>& c,const point&pt)
 {
 	log_info("on_point...cardid:%d,type:%d",c->m_id,c->m_type);
 	setLandmark(pt);
-
-	std::vector<std::shared_ptr<area>> areas=area_list::instance()->get_area(s, pt);//找出所有的区域
-	int sa = c->get_area();
-	if(sa!=-1)
+	
+	int special_area=-1;
+	std::vector<std::shared_ptr<area>> areas=area_list::instance()->get_area(s,c, pt,special_area);
+	if(special_area != -1)
 	{
-		auto area_=area_list::instance()->get(sa);
+		areas.clear();
+		auto area_=area_list::instance()->get(special_area);
 		areas.push_back(area_);
 	}
-	std::sort(areas.begin(),areas.end(),[](const std::shared_ptr<area>&l,const std::shared_ptr<area>&r){
-			return l->id()<r->id();
-			});
+	else
+		std::sort(areas.begin(),areas.end(),[](const std::shared_ptr<area>&l,const std::shared_ptr<area>&r){
+				return l->id()<r->id();
+				});
 
 	auto c1=m_hover_list.begin(),ce=m_hover_list.end();
 	auto a1=areas.begin() ,ae=areas.end();

area.h

@@ -21,23 +21,12 @@ struct site;
 */
 struct area
 {
-    area(int id,int limit_count_person, int limit_time_person,double scale,int32_t mapid,int32_t type)
-        :m_id(id)
-        ,m_area_type(type)
-        ,m_limit_person_second(limit_time_person)
-        ,m_limit_person_count(limit_count_person)
-        ,m_scale(scale)
-        ,m_mapid(mapid)
-        ,m_person_count(0)
-        ,m_vehicle_count(0)
-    {
-    }
-
-	virtual void on_hover(std::shared_ptr<area_hover>&a,std::shared_ptr<card_location_base>&c);
-	virtual	void on_enter(std::shared_ptr<area_hover>&a,std::shared_ptr<card_location_base>&c);
-	virtual	void on_leave(std::shared_ptr<area_hover>&a,std::shared_ptr<card_location_base>&c);
+    area(int id,int limit_count_person, int limit_time_person,double scale,int32_t mapid,int32_t type);
+  	virtual void on_hover(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c);
+	virtual	void on_enter(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c);
+	virtual	void on_leave(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c);
 
-    virtual bool in_area(const std::shared_ptr<site>&s, const point & p);
+    virtual bool in_area(const std::shared_ptr<site>&s,const std::shared_ptr<card_location_base>&c, const point & p,int &);
     int id()const
     {
         return m_id;
@@ -109,12 +98,13 @@ struct area_list:single_base<area_list,int,std::shared_ptr<area>>
     area_list();
 
 	//根据分站、所在点找出所在区域列表
-	std::vector<std::shared_ptr<area>> get_area(const std::shared_ptr<site> s,const point&pt);
+	std::vector<std::shared_ptr<area>> get_area(const std::shared_ptr<site> s,const std::shared_ptr<card_location_base> &c,const point&pt,int &);
     std::vector<point> init_path(std::string  &str);
     ///id=-1为初始化所有
     void init_from_db(int id=-1);
     void init_monkeycar_area(int id=-1);
 private:
+	std::shared_ptr<area>  create(int type,int id,int limit_count_person, int limit_time_person,double scale,int32_t mapid,int32_t b_type);
     //禁区功能-给禁区中的卡发送警告及呼叫
     void CheckAreaType(int area_id,int new_area_type,int old_area_type);
     void CheckAreaType( std::shared_ptr<area> pArea,int new_area_type,int old_area_type);
@@ -209,14 +199,14 @@ struct area_tool
 		return m_hover_list.front();
 	}
 
-	void init_area(std::shared_ptr<area>&a,const point&pt,std::shared_ptr<card_location_base> c)
+	void init_area(std::shared_ptr<area>&a,const point&pt,const std::shared_ptr<card_location_base> &c)
 	{
 		m_hover_list.clear();
 		m_hover_list.push_back(std::make_shared<area_hover>(a,pt));
 		a->on_enter(m_hover_list.back(), c);
 	}
 
-	void on_point(const std::shared_ptr<site>&s,std::shared_ptr<card_location_base> c,const point&pt);
+	void on_point(const std::shared_ptr<site>&s,const std::shared_ptr<card_location_base>& c,const point&pt);
 
     void setLandmark(const point &pt)
     {
@@ -231,8 +221,7 @@ struct area_tool
 		{
 			d=ha->landmark_dis;
 			if(d<dis){
-				dis=d;
-				tmp = ha;
+				dis=d;tmp = ha;
 			}
 		}	
 		if(tmp)

area_business.cpp

@@ -17,14 +17,10 @@ struct area_business_post_area:area_business
 		return 1;
 	}
 	//将推送区域信息加入人员数据
-	virtual void on_enter(std::shared_ptr<area_hover>&a,std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr)
-	{
-	}
-
+	virtual void on_enter(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
+	virtual void on_hover(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
 	//从人员数据中清除区域信息
-	virtual void on_leave(std::shared_ptr<area_hover>&a,std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr)
-	{
-	}
+	virtual void on_leave(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
 };
 
 /*
@@ -46,22 +42,12 @@ struct area_business_speed_checker:area_business
 	}
 
 	//在ptr对象中初始化超速检测所需的对象
-	virtual void on_enter(std::shared_ptr<area_hover>&a,std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr)
-	{
-	}
-
+	virtual void on_enter(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
 	//根据超速检测的策略，进行超速判断，超速时进行告警
-	//建议使用最近M秒内N秒超时进行判断,M=20,N=15，策略数据记录在ptr中
-	virtual void on_hover(std::shared_ptr<area_hover>&a,std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr)
-	{
-
-	
-	}
-
+	//建议使用最近M秒内N秒超时进行判断,M=20,N=15，策略数据记录在ptr中..如此:一辆车理想情况下15s才能检测出来。15*4m/s=60mbut.15s内有可能只上来一个超速点。
+	virtual void on_hover(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
 	//清除超速检测所需的对象
-	virtual void on_leave(std::shared_ptr<area_hover>&a,std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr)
-	{
-	}
+	virtual void on_leave(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
 };
 
 
@@ -76,15 +62,14 @@ struct area_business_restricted:area_business
 		return 7;
 	}
 	//记录进入时间等信息,生成告警
-	virtual void on_enter(std::shared_ptr<area_hover>&a,std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> )
+	virtual void on_enter(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr)
 	{
-
+#if 0
         a->m_enter_point = point(c->x,c->y,c->z);
         a->m_last_point.set(0,0,0);
         a->m_last_time = 0;
         a->m_enter_time = time(nullptr);
 
-        // 发送警告
         event_ptr evPtr = event_list::instance()->get_event_card(c->m_id,c->m_type,ET_CARD_AREA_FORBIDDEN_PERSON);
         if (nullptr == evPtr)
         {
@@ -102,11 +87,14 @@ struct area_business_restricted:area_business
 
         //呼叫
         module_call::instance()->system_call_apoint(c->m_id,c->m_type);
-	}
+#endif
 
+	}
+	virtual void on_hover(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
 	//记录退出时间等信息
-	virtual void on_leave(std::shared_ptr<area_hover>&a,std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr)
+	virtual void on_leave(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr)
 	{
+#if 0
         a->m_last_point = point(c->x,c->y,c->z);
         a->m_last_time = time(nullptr);
 
@@ -136,6 +124,7 @@ struct area_business_restricted:area_business
         }
         //取消呼叫
         module_call::instance()->system_cancel_call_apoint(c->m_id,c->m_type);
+#endif
     }
 };
 
@@ -146,23 +135,8 @@ struct area_business_monkey_area:area_business
 {
 	virtual int area_business_type()
 	{
-
 		return 8;
 	}
-
-	virtual void on_enter(std::shared_ptr<area_hover>&a,std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr)
-	{
-	
-	}
-
-	virtual void on_hover(std::shared_ptr<area_hover>&a,std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr)
-	{
-	
-	}
-
-	virtual void on_leave(std::shared_ptr<area_hover>&a,std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr)
-	{
-	}
 };
 
 /*
@@ -176,15 +150,10 @@ struct area_business_car_attendance:area_business
 	
 	}
 	//记录进入时间等信息,结束考勤,根据离开的时间和距离，判断是否记录一条新的考勤记录
-	virtual void on_enter(std::shared_ptr<area_hover>&a,std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr)
-	{
-	
-	}
-
+	virtual void on_enter(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
+	virtual void on_hover(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
 	//记录离开考勤区域信息,开始考勤
-	virtual void on_leave(std::shared_ptr<area_hover>&a,std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr)
-	{
-	}
+	virtual void on_leave(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
 };
 
 /*
@@ -198,15 +167,10 @@ struct area_business_person_attendance:area_business
 	
 	}
 	//记录进入时间等信息,开始考勤
-	virtual void on_enter(std::shared_ptr<area_hover>&a,std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr)
-	{
-	
-	}
-
+	virtual void on_enter(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
+	virtual void on_hover(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
 	//记录离开考勤区域信息,结束考勤
-	virtual void on_leave(std::shared_ptr<area_hover>&a,std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr)
-	{
-	}
+	virtual void on_leave(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
 };
 
 /*
@@ -223,17 +187,10 @@ struct area_business_count_checker:area_business
 	
 	}
 	//增加计数,并进行判断
-	virtual void on_enter(std::shared_ptr<area_hover>&a,std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr)
-	{
-
-	}
-
+	virtual void on_enter(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
+	virtual void on_hover(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
 	//减少计数
-	virtual void on_leave(std::shared_ptr<area_hover>&a,std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr)
-	{
-		
-	
-	}
+	virtual void on_leave(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
 };
 
 
@@ -248,17 +205,12 @@ struct area_business_person_dwell_checker:area_business
 	{
 		return 2;
 	}
-	//初始化 ptr 的相关数据项
-	virtual void on_enter(std::shared_ptr<area_hover>&a,std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr)
-	{
-	
-	}
-
-	//更新 ptr 的相关数据项,并进行超时判断
-	virtual void on_hover(std::shared_ptr<area_hover>&a,std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr)
-	{
-	
-	}
+	//进入区域，记录进入时间
+	virtual void on_enter(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
+	//判断是否超时
+	virtual void on_hover(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
+	//如果有超时告警，取消超时告警
+	virtual void on_leave(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
 };
 
 struct area_business_card_enter_or_leave:area_business
@@ -267,17 +219,11 @@ struct area_business_card_enter_or_leave:area_business
 	{
 		return 9;
 	}
-	//初始化 ptr 的相关数据项
-	virtual void on_enter(std::shared_ptr<area_hover>&a,std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr)
-	{
-	
-	}
-
-	//更新 ptr 的相关数据项,并进行超时判断
-	virtual void on_leave(std::shared_ptr<area_hover>&a,std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr)
-	{
-	
-	}
+	//进入区域则入库操作
+	virtual void on_enter(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
+	virtual void on_hover(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
+	//出区域则入库
+	virtual void on_leave(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
 };
 
 struct area_business_factory

area_business.h

@@ -13,9 +13,9 @@ struct area_business
 {
 	virtual int area_business_type()=0;
 
-	virtual void on_enter(std::shared_ptr<area_hover>&a,std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
-	virtual void on_hover(std::shared_ptr<area_hover>&a,std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
-	virtual void on_leave(std::shared_ptr<area_hover>&a,std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
+	virtual void on_enter(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
+	virtual void on_hover(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
+	virtual void on_leave(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
 
 	static std::vector<area_business*> get_instance_list(int business_type);
 };

card.cpp

@@ -408,8 +408,8 @@ void card_list::on_message(zloop<task*> *loop,const message_locinfo&loc,bool is_
 
 bool card_list_visit::visit(std::shared_ptr<card_location_base> c)
 {
-	if(c->on_timer())
-		mine_business::inst()->put(c);
+//	if(c->on_timer())
+//		mine_business::inst()->put(c);
 	return true;	
 }
 

card_base.cpp

@@ -28,11 +28,7 @@ void card_location_base::do_status(int st)
 
 void card_location_base::on_location(const std::vector<point>&vp,const std::vector<loc_message> &lm )
 {
-	//ct timestamp;
-	//m_ct = lm[0].m_card_ct;
-	//m_time = lm[0].m_loc_time;
-
-    loc_point pt = m_sel_tool->select_solution(vp,lm);
+	loc_point pt = m_sel_tool->select_solution(vp,lm);
 	pt.y=-pt.y;
 	if(pt.m_useless)
 	{
@@ -71,7 +67,7 @@ void card_location_base::upt_card_pos(YA::_CARD_POS_&cp, const point &pt)
 	cp.display=m_display;
 	cp.rec_time=m_time;
 	cp.level_id = m_level_id;
-
+	
 	swsTimerThrd.upt_card_pos(cp);
 }
 void card_location_base::del_card_pos()

card_base.h

@@ -47,6 +47,7 @@ struct card:point
 		,m_time(0)
 		,m_deptid(deptid)
 		,m_level_id(level_id)
+		,m_biz_stat(0)
 	{}
 	uint64_t type_(){return m_type;}
 	uint64_t time_(){return m_time;}
@@ -61,10 +62,12 @@ struct card:point
     uint64_t m_time;			//时间戳 ms
 	int32_t  m_deptid;			//部门编号
 	int32_t  m_level_id;		//部门级别
+	int m_biz_stat;
 };
 
 struct card_location_base:card,std::enable_shared_from_this<card_location_base>
 {
+	uint64_t m_timeval=0;
     std::unique_ptr<select_tool> m_sel_tool;
     std::unique_ptr<smooth_tool> m_smo_tool;
 	std::unique_ptr<card_message_handle> m_message_handle;
@@ -74,7 +77,7 @@ struct card_location_base:card,std::enable_shared_from_this<card_location_base>
     card_location_base(std::string type,uint32_t id,uint16_t dis,int16_t t,int32_t,int32_t,uint32_t );
 
 	virtual void do_business(const std::shared_ptr<site>&site,const point &pt,double acc)=0;
-	virtual bool on_timer()=0;
+	virtual void on_timer()=0;
 	virtual void site_hover(int sid)=0;
     virtual std::shared_ptr<area_hover> get_area_hover()=0;
     virtual std::shared_ptr<mine_tool> get_mine_tool()=0;

card_car.cpp

@@ -27,10 +27,7 @@ car::~car(){}
 
 void car::site_hover(int sid)
 {
-	if(m_time<=0)
-	{
-		return;
-	}
+	if(m_time<=0)return;
 	m_site_area->on_point(m_id,sid,0, m_type);
 }
 
@@ -53,6 +50,7 @@ void car::do_business(const std::shared_ptr<site>&site,const point &pt,double ac
 {
 	m_acc=acc;
 	m_area_tool->on_point(site,shared_from_this(),pt);
+	m_timeval=m_time;
 	m_site_area->on_point(m_id,0,this, m_type);
 	m_mine_tool->on_point(m_id, m_type, m_vehicle_category_id);
 	handle_three_rates(pt);
@@ -68,7 +66,8 @@ int car::get_vehicle_type_id()
 void car::handle_three_rates(const point &pt)
 {
 	card_pos cp;
-	cp.biz_stat = get_stat();
+	m_biz_stat=get_stat();
+	cp.biz_stat = m_biz_stat;
 	cp.x=pt.x;cp.y=pt.y;cp.z=pt.z;	
 	const auto lm = m_area_tool->getLandmark();
 	cp.enter_time = std::get<0>(lm)*1000;
@@ -78,29 +77,24 @@ void car::handle_three_rates(const point &pt)
 	put_three_rates(cp);
 }
 
-bool car::on_timer()
+void car::on_timer()
 {
-	return make_package();
+	make_package();
 }
 int car::get_area()
 {
-	int status = get_stat();
+	int status = m_biz_stat;
 	int special_id = -1;
 	if(status == STATUS_LOST)
 	{
-#pragma message("special_area()咋删了");
-		//if(!m_area_tool->special_area())			
-		{
-			special_id = special_area_list::instance()->get_special_id(m_id,*this,m_vehicle_category_id);
-			log_info("enter_special_area:%.2f,%2.f,id:%d,special_area_id:%d",x,y,m_id,special_id);
-		}
+		special_id = special_area_list::instance()->get_special_id(m_id,*this,m_vehicle_category_id);
+		log_info("enter_special_area:%.2f,%2.f,id:%d,special_area_id:%d",x,y,m_id,special_id);
 	}
 	return special_id;
 }
 
-bool car::make_package()
+void car::make_package()
 {
-	bool f=false;
 	YA::_CARD_POS_ cp;
 	loc_point pt = getSmoothPoint();
 
@@ -113,8 +107,7 @@ bool car::make_package()
 	cp.landmark_id = std::get<4>(lm);
 	cp.lm_direction = std::get<5>(lm);
 	cp.landmark_dis=std::get<6>(lm);
-	//int32_t biz_stat=statbiz(special_id);
-	int32_t biz_stat=get_stat();
+	int32_t biz_stat=m_biz_stat;
 	
 	cp.biz_stat=biz_stat;
 	cp.down_time = m_mine_tool->get_down_time();
@@ -122,16 +115,25 @@ bool car::make_package()
 	cp.is_on_duty=m_mine_tool->is_on_duty();
 	upt_card_pos(cp,pt);
 	m_his_location_card->push(pt.m_time,pt,area_id,map_id);
+	uint64_t _now=tool_time::now_to_ms();
+	uint64_t t=_now>m_timeval?_now-m_timeval:m_timeval-_now;
+	if(t>10*1000)
+	{
+		auto site = m_site_area->get_site();
+		m_area_tool->on_point(site,shared_from_this(),pt);
+		m_biz_stat=get_stat();
+	}
+
 //	if(biz_stat==STATUS_LOST && special_id != -1 && m_display==1)
 //	{
 //		cp.area_id = special_id;
 //		swsClientMgr.SendSpecialAreaProcess(cp);
 //	}
-	uint64_t _now=tool_time::now_to_ms();
-	uint64_t t=_now>m_time?_now-m_time:m_time-_now;
-	if(t<45*1000 && !empty())
-	  f=true;
-	return f;
+//	uint64_t _now=tool_time::now_to_ms();
+//	uint64_t t=_now>m_time?_now-m_time:m_time-_now;
+//	if(t<45*1000 && !empty())
+//	  f=true;
+//	return f;
 }
 loc_point car::getSmoothPoint()
 {

card_car.h

@@ -37,9 +37,9 @@ public:
 
 private:
 	void handle_three_rates(const point &pt);
-	bool on_timer();
+	void on_timer();
 	//int statbiz(int32_t special_id);
-	bool make_package();
+	void make_package();
 	loc_point getSmoothPoint();
 
 	virtual std::tuple<time_t,time_t,int,int,int,int,double,double> getLandmark();

card_person.cpp

@@ -91,6 +91,7 @@ std::shared_ptr<site_area_hover> person::get_site_area()
 void person::do_business(const std::shared_ptr<site>&site,const point &pt,double acc)
 {
 	m_area_tool->on_point(site,shared_from_this(),pt);
+	m_timeval=m_time;
 	m_site_area->on_point(m_id,0,this, m_type);
 	handle_three_rates(pt);
 }
@@ -108,7 +109,8 @@ void person::handle_three_rates(const point & pt)
 {
 	card_pos cp;
 	cp.work_line=m_workLine;
-	cp.biz_stat = get_stat();
+	m_biz_stat=get_stat();
+	cp.biz_stat = m_biz_stat;
 	cp.x=pt.x;cp.y=pt.y;cp.z=pt.z;	
 	const auto lm = m_area_tool->getLandmark();
 	cp.enter_time = std::get<0>(lm)*1000;
@@ -116,13 +118,13 @@ void person::handle_three_rates(const point & pt)
 	put_three_rates(cp);
 }
 
-bool person::on_timer()
+void person::on_timer()
 {
 	//人员井下超时
 //    m_mine_tool->on_check_overtime(this->m_id,this->m_type);
 
 	if(!m_mine_tool->is_attendance())
-		return false;
+		return;
 	YA::_CARD_POS_ cp;
 	if(m_display)
 	  mine_business::inst()->fetch_add();
@@ -140,14 +142,21 @@ bool person::on_timer()
 	cp.lm_direction = std::get<5>(lm);
 	cp.landmark_dis=std::get<6>(lm);
 
-	cp.biz_stat = get_stat();
+	cp.biz_stat = m_biz_stat;
 	cp.down_time = m_mine_tool->get_down_time();
 	cp.work_time = m_mine_tool->get_work_time();
 	cp.is_on_duty= m_mine_tool->is_on_duty();
 	log_info("on_timer here ...%d,%lld,%.2f,%.2f,%d,%d",m_id,_time,pt.x,pt.y,area_id,map_id);
 	m_his_location_card->push(_time,pt,area_id,map_id);
 	upt_card_pos(cp,pt);
-	return false;
+	uint64_t _now=tool_time::now_to_ms();
+	uint64_t t=_now>m_timeval?_now-m_timeval:m_timeval-_now;
+	if(t>10*1000)
+	{
+		auto site = m_site_area->get_site();
+		m_area_tool->on_point(site,shared_from_this(),pt);
+		m_biz_stat=get_stat();
+	}
 }
 
 point person::getSmoothPoint(uint64_t& t)

card_person.h

@@ -17,7 +17,7 @@ struct person:card_location_base, card_area
     void clear();
 	void reset(std::shared_ptr<monkey_person> mp);
 	void handle_three_rates(const point & pt);
-	bool on_timer();
+	void on_timer();
 	void IKSDK_DB(int);
 	point getSmoothPoint(uint64_t& t);
 

common.h

@@ -64,7 +64,12 @@ enum CARD_TYPE
 
 enum AREA_TYPE
 {
+	AREA_TYPE_UPMINE =0,
+	AREA_TYPE_NORMAL=1,
+	AREA_TYPE_IMPORT=2,
 	AREA_TYPE_FORBIDDEN = 3,	// 限制区域
+	AREA_TYPE_DOWNMINE=4,
+	AREA_TYPE_MONKEY=5,
 	AREA_TYPE_NO_COVER = 1000,	// 非覆盖区域，车辆信号消失后，定位到附近非覆盖区域内
 	AREA_TYPE_SPECIAL = 1001	// 特殊区域，只给你前端用来标识是否显示图标,胶轮车硐室
 };

event.h

@@ -41,6 +41,11 @@ enum EVENT_TYPE{ // 事件类型
 class Event;
 struct event_tool
 {
+	template <class UnaryPredicate>
+	void handle_event(OBJECT_TYPE ot,EVENT_TYPE et,uint64_t id,double limit_value,double cur_value,Unarypredicate p)
+	{
+		handle_event(ot,et,id,limit_value,cur_value,p());
+	}
 	void handle_event(OBJECT_TYPE ot,EVENT_TYPE et,uint64_t id,double limit_value,double cur_value,bool f);
 	static event_tool * instance();
 private:

main.cpp

@@ -62,7 +62,7 @@ struct Init_Setting
 
         //auto a = Landmark_list::instance()->get(5,id,pt);
         //std_info("test landmark:id:%d,dir:%d,dis:%.2f",std::get<0>(a),std::get<1>(a),std::get<2>(a));
-        //special_area_list::instance()->init_from_db();
+        special_area_list::instance()->init_from_db();
         //auto s = special_area_list::instance()->get_special_id(1013,point(4727,-254),2);
         //std_info("test special_area:%d",s);
 		mine_business::inst()->load();

monkey_car/monkeycar_area.cpp

@@ -3,6 +3,7 @@
 #include "monkeycar_person.h"
 #include "card.h"
 #include "log.h"
+#include "common.h"
 
 uint64_t monkey_area::m_startTime=time(NULL)*1000;
 
@@ -28,42 +29,35 @@ std::shared_ptr<monkey_person> monkey_area::find(uint32_t cardid)
 	return it->second;
 }
 
-void monkey_area::on_hover(int64_t card_id,std::shared_ptr<area_hover>&c,double speed,uint64_t type)
+void monkey_area::on_hover(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c)
 {
-	//area::on_hover(card_id,c,speed,type);
-	//人卡走下面的业务
-	if(type != 1)
-	  return;
-
-	uint64_t cid = type<<32|card_id;
-	const std::shared_ptr<card_location_base> card = card_list::instance()->get(cid);
+	area::on_hover(a,c);
+	if(c->m_type != CT_PERSON)return;
 
 	st_coord pt;
-	pt.x_=card->x;
-	pt.y_=card->y;
-	pt.m_ct = card->m_ct;
-	pt.gen_time_ = card->m_time-m_startTime;
+	pt.x_=c->x;
+	pt.y_=c->y;
+	pt.m_ct = c->m_ct;
+	pt.gen_time_ = c->m_time-m_startTime;
+
+	on_card_move(c->m_id,pt,c->m_type);
+
 
-	on_card_move(card_id,pt,type);
 }
-void monkey_area::on_enter(int64_t card_id,std::shared_ptr<area_hover>&c,double speed,uint64_t type)
+void monkey_area::on_enter(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c)
 {
-	//std::shared_ptr<card_location_base> card = card_list::instance()->get(tool_other::type_id_to_u64(type, card_id));
-	//area::on_enter(card_id,c,speed,type);
+	area::on_enter(a,c);
+	if(c->m_type != CT_PERSON)return;
+	on_card_enter(c);
 
-	if(type != 1)
-	  return;
-	on_card_enter(card_id,type);
 }
-void monkey_area::on_leave(int64_t card_id,std::shared_ptr<area_hover>&c,double speed,uint64_t type)
+void monkey_area::on_leave(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c)
 {
-	//area::on_leave(card_id,c,speed,type);
-	if(type != 1)
-	  return;
-	on_card_leave(card_id);
-}
-
+	area::on_leave(a,c);
+	if(c->m_type != CT_PERSON)return;
+	on_card_leave(c->m_id);
 
+}
 void monkey_area::on_card_leave(uint32_t cardid)
 {
 	log_info("[monkeycar on_card_leave]cardId:%d",cardid);
@@ -77,35 +71,29 @@ void monkey_area::on_card_leave(uint32_t cardid)
 	}
 	
 }
-void monkey_area::on_card_enter(uint32_t cardid,uint64_t type)
+void monkey_area::on_card_enter(const std::shared_ptr<card_location_base> &card)
 {
-	//log_info("[framework on_card_enter]cardId:%d",card_id);
-	log_info("[monkeycar on_card_enter]cardId:%d",cardid);
+	log_info("[monkeycar on_card_enter]cardId:%d",card->m_id);
 	auto me = shared_from_this();
 
 	std::shared_ptr<monkey_person> mp = std::make_shared<monkey_person>(me);
 
-	uint64_t c = type<<32|cardid;
-	const std::shared_ptr<card_location_base> card = card_list::instance()->get(c);
-	if(card==nullptr)
-	{
-		log_error("[monkeycar ----on_card_enter 卡未找到。]cardId:%d",cardid);
-		return;
-	}
 	card->reset(mp);
 
 	std::lock_guard<std::mutex> lk(m_mtx);
-	card_map_.insert(std::make_pair(cardid,mp));
+	card_map_.insert(std::make_pair(card->m_id,mp));
 }
 void monkey_area::on_card_move(uint32_t cardid,const st_coord & st,uint64_t type)
 {
 	log_info("[monkeycar on_card_move]cardId:%d",cardid);
-	auto me = shared_from_this();
+	//auto me = shared_from_this();
 	auto mp=find(cardid);
 	if (!mp)
 	{
 		//if not exist ,create it .because may be restart the system.then area has not changed.
-		on_card_enter(cardid,type); 
+		uint64_t id=type<<32|cardid;
+		if(auto c=card_list::instance()->get(id))
+			on_card_enter(c); 
 		return ;
 	}
 	bool ret = mp->on_step_map(st);

monkey_car/monkeycar_area.h

@@ -27,15 +27,12 @@ public:
 	{}
 	std::shared_ptr<monkey_person> find(uint32_t cardid);
 
-    virtual void on_hover(std::shared_ptr<area_hover>&a,std::shared_ptr<card_location_base>&c){}
-	virtual void on_enter(std::shared_ptr<area_hover>&a,std::shared_ptr<card_location_base>&c){}
-	virtual void on_leave(std::shared_ptr<area_hover>&a,std::shared_ptr<card_location_base>&c){}
 
-    virtual void on_hover(int64_t card_id,std::shared_ptr<area_hover>&c,double speed,uint64_t type);
-    virtual void on_enter(int64_t card_id,std::shared_ptr<area_hover>&c,double speed,uint64_t type);
-    virtual void on_leave(int64_t card_id,std::shared_ptr<area_hover>&c,double speed,uint64_t type);
+	virtual void on_hover(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c);
+	virtual	void on_enter(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c);
+	virtual	void on_leave(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c);
 	void on_card_leave(uint32_t cardid);
-	void on_card_enter(uint32_t cardid,uint64_t type);
+	void on_card_enter(const std::shared_ptr<card_location_base>&);
 	void on_card_move(uint32_t cardid,const st_coord & st,uint64_t);
 	
 	inline  double map(double x, double y)

site_area.cpp

@@ -1,12 +1,16 @@
 
 #include "site_area.h"
 #include "card.h"
+#include "ant.h"
 #include "module_service/module_site.h"
 
 //每张卡包含这样一个对象，保存最后一个分站区域
 //1、记录卡进出分站的时间，地点
 //2、用于考勤
-
+std::shared_ptr<site> site_area_hover::get_site()
+{
+	return sit_list::instance()->get(m_site_id);
+}
 void site_area_hover::on_point(uint32_t card_id,int site_id,const point*pt,int32_t type)
 {
 	if(pt!=nullptr)

site_area.h

@@ -1,12 +1,14 @@
 #ifndef __SITE_AREA_HOVER_HPP__
 #define __SITE_AREA_HOVER_HPP__
 #include <point.h>
+#include <memory>
 #include <chrono>
 #include "common.h"
 
 //每张卡包含这样一个对象，保存最后一个分站区域；只有tof一维有这个需求
 //1、记录卡进出分站的时间，地点
 //2、用于考勤
+class site;
 struct site_area_hover
 {
     site_area_hover()
@@ -39,6 +41,8 @@ public:
     {
         return -1==m_site_id;
     }
+	std::shared_ptr<site> get_site();
+
 };
 #endif