Module (II): Detecting the Presence of the Target Node in the Desired Workspaces.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importing the Required Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "import math\n",
    "from datetime import datetime\n",
    "import seaborn as sns\n",
    "from sklearn.neighbors import DistanceMetric\n",
    "from shapely.geometry import Point, Polygon\n",
    "from sklearn.metrics import classification_report,confusion_matrix\n",
    "from sklearn.metrics import precision_recall_fscore_support\n",
    "from scipy.stats import mode"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Importing the Dataset Containing Physical Context Information From the BIM Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "df=pd.read_csv(r\"G:\\RTLS-BIM\\Experiment8_zone_detection_pattern6\\model_zone_detection5.csv\")\n",
    "\n",
    "#Changing the type of the numeric attributes to the float\n",
    "Part1=df.drop(['family_type','comment'],axis=1).astype(float)\n",
    "df=pd.concat([df[['family_type','comment']],Part1], axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Importing the Dataset Containing the Target Estimated Locations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "data =pd.read_csv(r\"G:\\RTLS-BIM\\Experiment8_zone_detection_pattern6\\Experiment8_zone_detection_pattern6.csv\")\n",
    "\n",
    "#Correcting the timestamp of the dataset\n",
    "\n",
    "alk=pd.DataFrame(data['timestamp'].apply(lambda x: x.replace('@','')))\n",
    "data['timestamp']=pd.DataFrame(pd.to_datetime(alk['timestamp'], infer_datetime_format=True))\n",
    "\n",
    "# adding the z-axes to the locations\n",
    "\n",
    "data['location_Z']=0\n",
    "\n",
    "data=data.dropna().drop_duplicates(subset=['timestamp']).sort_values('timestamp').reset_index(drop=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Generating a dataset in which the number of records (locations) multiplied by the number of elements and the dataset of the element (x,y) coordinates is repeated by the number of the records. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "Locations=pd.DataFrame(np.repeat(data.values, len(df.index), axis=0), columns=data.columns)\n",
    "Geo=pd.concat([df]*len(data.index))\n",
    "Geo=Geo.reset_index(drop=True)\n",
    "Final=pd.concat([Locations,Geo], axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Checking the zone where the target is located"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "acx1=list(Final[['X1','Y1']].to_records(index=False))\n",
    "acx2=list(Final[['X2','Y2']].to_records(index=False))\n",
    "acx3=list(Final[['X3','Y3']].to_records(index=False))\n",
    "acx4=list(Final[['X4','Y4']].to_records(index=False))\n",
    "cxx=Final['location_X']\n",
    "cxy=Final['location_Y']\n",
    "\n",
    "rows5 = []\n",
    "for (a,b) in zip(zip(acx1,acx2,acx3,acx4),zip(cxx,cxy)):\n",
    "        poly = (Polygon(a))\n",
    "        p1 = Point((b))\n",
    "        polyy=poly.contains(p1)\n",
    "        rows5.append(polyy)\n",
    "    \n",
    "Final['surrounded']=pd.DataFrame(rows5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "Final=Final.iloc[Final.groupby(Final.index // len(df.index)).surrounded.idxmax()].reset_index()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Here is an algorithm to calculate the distance of a target point from a segment (of an element) and to detrmine the (x,y) coordiantes of the nearest point on the segment to the target point"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def dot(v,w):\n",
    "    x,y,z = v\n",
    "    X,Y,Z = w\n",
    "    return x*X + y*Y + z*Z\n",
    "\n",
    "def length(v):\n",
    "    x,y,z = v\n",
    "    return math.sqrt(x*x + y*y + z*z)\n",
    "\n",
    "def vector(b,e):\n",
    "    x,y,z = b\n",
    "    X,Y,Z = e\n",
    "    return (X-x, Y-y, Z-z)\n",
    "\n",
    "def unit(v):\n",
    "    x,y,z = v\n",
    "    mag = length(v)\n",
    "    return (x/mag, y/mag, z/mag)\n",
    "\n",
    "def distance(p0,p1):\n",
    "    return length(vector(p0,p1))\n",
    "\n",
    "def scale(v,sc):\n",
    "    x,y,z = v\n",
    "    return (x * sc, y * sc, z * sc)\n",
    "\n",
    "def add(v,w):\n",
    "    x,y,z = v\n",
    "    X,Y,Z = w\n",
    "    return (x+X, y+Y, z+Z)\n",
    "\n",
    "def pnt2line(pnt, start, end):\n",
    "    line_vec = vector(start, end)\n",
    "    pnt_vec = vector(start, pnt)\n",
    "    line_len = length(line_vec)\n",
    "    line_unitvec = unit(line_vec)\n",
    "    pnt_vec_scaled = scale(pnt_vec, 1.0/line_len)\n",
    "    t = dot(line_unitvec, pnt_vec_scaled)    \n",
    "    if t < 0.0:\n",
    "        t = 0.0\n",
    "    elif t > 1.0:\n",
    "        t = 1.0\n",
    "    nearest = scale(line_vec, t)\n",
    "    dist = distance(nearest, pnt_vec)\n",
    "    nearest = add(nearest, start)\n",
    "    return (dist, nearest)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Applying the algorithm for the segments of each element "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "pnt1=list(Final[['location_X','location_Y','location_Z']].to_records(index=False))\n",
    "start1=list(Final[['X1','Y1','Z1']].to_records(index=False))\n",
    "end1=list(Final[['X2','Y2','Z2']].to_records(index=False))\n",
    "\n",
    "pnt2=list(Final[['location_X','location_Y','location_Z']].to_records(index=False))\n",
    "start2=list(Final[['X2','Y2','Z2']].to_records(index=False))\n",
    "end2=list(Final[['X3','Y3','Z3']].to_records(index=False))\n",
    "\n",
    "pnt3=list(Final[['location_X','location_Y','location_Z']].to_records(index=False))\n",
    "start3=list(Final[['X3','Y3','Z3']].to_records(index=False))\n",
    "end3=list(Final[['X4','Y4','Z4']].to_records(index=False))\n",
    "\n",
    "pnt4=list(Final[['location_X','location_Y','location_Z']].to_records(index=False))\n",
    "start4=list(Final[['X4','Y4','Z4']].to_records(index=False))\n",
    "end4=list(Final[['X1','Y1','Z1']].to_records(index=False))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "rows1 = []\n",
    "for i, b, s in zip(pnt1,start1,end1):\n",
    "    m=(pnt2line(i,b,s))\n",
    "    rows1.append(m)\n",
    "    \n",
    "Intersect1=pd.DataFrame(rows1).rename({0:'distance1',1:'intersection_coordinates1'},axis=1)\n",
    "\n",
    "rows2 = []\n",
    "for i, b, s in zip(pnt2,start2,end2):\n",
    "    m=(pnt2line(i,b,s))\n",
    "    rows2.append(m)\n",
    "\n",
    "Intersect2=pd.DataFrame(rows2).rename({0:'distance2',1:'intersection_coordinates2'},axis=1)\n",
    "\n",
    "rows3 = []\n",
    "for i, b, s in zip(pnt3,start3,end3):\n",
    "    m=(pnt2line(i,b,s))\n",
    "    rows3.append(m)\n",
    "    \n",
    "Intersect3=pd.DataFrame(rows3).rename({0:'distance3',1:'intersection_coordinates3'},axis=1)\n",
    "\n",
    "rows4 = []\n",
    "for i, b, s in zip(pnt4,start4,end4):\n",
    "    m=(pnt2line(i,b,s))\n",
    "    rows4.append(m)\n",
    "\n",
    "Intersect4=pd.DataFrame(rows4).rename({0:'distance4',1:'intersection_coordinates4'},axis=1)\n",
    "\n",
    "Merged=pd.concat([Final,Intersect1,Intersect2,Intersect3,Intersect4],axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####  The time difference between two executive records is calculated to find the time spent on the workspaces by the target"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "Final['diff_seconds'] = pd.DataFrame(Final['timestamp'].diff(1))['timestamp'].dt.total_seconds()\n",
    "Final=Final[['timestamp', 'family_type', 'comment',\n",
    "       'element_id', 'surrounded', 'diff_seconds','experiment']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# To remove noises and downtime of the BLE beacons worn by the workers, the records generated after 6 seconds should be removed.\n",
    "Final=Final[(Final['diff_seconds']<=5)].sort_values('timestamp').reset_index().drop('index',axis=1)\n",
    "Final['comment'].fillna('safe', inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Actual Time Spent and Records Frequency in the Workspaces"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>time_spent</th>\n",
       "      <th>records_number</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>comment</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>safe</th>\n",
       "      <td>2.0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>workspace_A</th>\n",
       "      <td>209.0</td>\n",
       "      <td>113</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>workspace_B</th>\n",
       "      <td>172.0</td>\n",
       "      <td>91</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>workspace_C</th>\n",
       "      <td>263.0</td>\n",
       "      <td>136</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>workspace_D</th>\n",
       "      <td>165.0</td>\n",
       "      <td>92</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>workspace_E</th>\n",
       "      <td>203.0</td>\n",
       "      <td>109</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             time_spent  records_number\n",
       "comment                                \n",
       "safe                2.0               1\n",
       "workspace_A       209.0             113\n",
       "workspace_B       172.0              91\n",
       "workspace_C       263.0             136\n",
       "workspace_D       165.0              92\n",
       "workspace_E       203.0             109"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "time_spent = Final.groupby('comment').sum()\n",
    "records_number = pd.DataFrame(Final.groupby('comment').count()['timestamp'])\n",
    "final_dataset = pd.merge(time_spent, records_number, left_index=True, right_index=True)\n",
    "final_dataset = final_dataset.drop(['element_id','surrounded'],axis=1)\n",
    "final_dataset.rename({'diff_seconds':'time_spent','timestamp':'records_number'},axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}