text: import numpy as np
  import pandas as pd
  from sklearn.manifold import MDS
  import os, sys
  src_dir = os.path.join(r'C:\Users\UOU\Desktop\GJ\openbadge-analysis-master')
  sys.path.append(src_dir)
  
  
  # add the 'src' directory as one where we can import modules
  
  
  import openbadge_analysis as ob
  from openbadge_analysis import core
  from openbadge_analysis.visualization.mds_with_anchors import smacof
  
  
  def rssi_to_distance(rssi, P=-61.5, n=2.6):
      """
      매개 변수
      ----------
      rssi : 숫자 또는 배열
      RSSI 값 또는 RSSI 값의 배열입니다.
  
      P : 플로트
      1미터에 대한 RSSI 값입니다. 기본값은 -61.5입니다.
  
      n : 플로트
      RSSI를 미터로 변환할 때 사용되는 "scaling factor"입니다. 기본값은 2.6입니다.
  
      return
      ------- 
      숫자 또는 배열:
      미터 단위로 측정한 거리 또는 거리 배열입니다.
      """
      # NOTE for the paper I used -60 and 2.4
      return np.power(10, (P - rssi)/(10*n))
  # RSSI 값으로부터의 거리를 미터 단위로 계산합니다.
  
  def coords_to_distance(coords):
      """
      매개 변수
      ----------
      cords: pd.데이터프레임
          각 점의 좌표입니다.  단일 인덱스와 'x' 및 'y' 열이 있어야 합니다.
      
      돌아온다
      -------
      pd.Series:
          'cords'의 인덱스 이름에 의해 인덱스된 거리는 '1'과 '2'가 붙는다.
      """
      
      index_name = coords.index.names[0]
      
      coords = coords.copy()
  
      # Make the scalar product of `coords` with itself
      coords['_tmpkey'] = 1
      distances = pd.merge(coords, coords, on='_tmpkey', suffixes=('1', '2')).drop('_tmpkey', axis=1)
      distances.index = pd.MultiIndex.from_product((coords.index, coords.index))
      distances.index.names = [index_name + '1', index_name + '2']
      coords.drop('_tmpkey', axis=1, inplace=True)
  
      del coords
      
      # Compute the Euclidean distance for each pair of points
      distances['distance'] = distances.apply(
          lambda df: np.sqrt((df['x1'] - df['x2'])**2 + (df['y1'] - df['y2'])**2),
          axis=1
      )
      
      return distances['distance']
  # 좌표 리스트를 이러한 좌표의 각 점 사이의 거리 리스트로 변환합니다.
  
  
  def members_2d_embedding(m2m, prev=None, P=-61.5, n=2.6, method='weighted', random_state=0):
      """Computes a 2D embedding of the members through multidimensional scaling.
      
      Parameters
      ----------
      m2m : pandas.DataFrame
          'datetime', 'member1', 'member2'로 인덱싱 된 Member-to-member 의 proximity 데이터
          
      prev : None or pd.DataFrame
          None이 아닌 경우 이 함수에 의해 member의 위치가 반환됨.
          이것은 이전에 계산된 MDS 값으로 MDS를 초기화하는데 사용될 수 있다.
          (예시 : 시계열을 만든다.)
          defaluts는 None값
      
      P : float
      n : float
          `rssi_to_distance`에 대한 파라미터
      
      method : str
          임베딩 계산에 사용되는 method. 
          '가중치' 혹은 'sklearn'중 하나. 
          defults는 '가중치'
  
      random_state : None, int or np.random.RandomState
          임베딩을 계산할 때 sklearn에 의해 사용되는 seed/RNG.
          default는 None
      
      Returns
      -------
      DataFrame :
          The (x, y) coordinates of each member.
          각 member에 대한 xy 좌표
      """
  
  
      
      # Initialize the RNG
      if type(random_state) != np.random.RandomState:
          random_state = np.random.RandomState(random_state)
      
      # The list of members
      members = sorted(list(set(list(m2m.reset_index()['member1']) + list(m2m.reset_index()['member2']))))
      
      # Member-to-member
      df = rssi_to_distance(m2m['rssi'], P=P, n=n).groupby(['member1', 'member2']).mean()
      df = df.append(df.reorder_levels([1, 0]))
      distances = df
      
      # Diagonal
      distances = distances.append(pd.Series(np.zeros(len(members)),
                                             index=pd.MultiIndex.from_tuples(zip(members, members))))
      
      # Remove duplicates, in case there are any (there shouldn't be)
      distances = distances[~distances.index.duplicated(keep='first')]
      
      # Distance matrix
      dist_matrix = distances.unstack()
      
      # This is to deal with a "bug/feature" in pandas
      # Using .loc on a DF that has non-int indexes will call .iloc internally, which is not what we want
      # Converting the indexes to a string fixes the problem
      dist_matrix.columns = dist_matrix.columns.astype(str)
      dist_matrix.index = dist_matrix.index.astype(str)
      
      # Convert into a numpy matrix, with the rows/columns containing
      # the members first and the beacons second
      D = dist_matrix.loc[map(str, members), map(str, members)].as_matrix()
      
      if method == 'weighted':
          # The weight matrix is set to 0. for missing values, and 1. everywhere else
          W = 1 - np.isnan(D)
  
          # Missing values in `D`
          D[np.isnan(D)] = 0.0  # Arbitrary value; those distances are ignored anyway
          
          init = None
          # If previous values were given for the members positions
          if prev is not None:
              # Select those that match our list of members
              prev = prev.loc[members]
              # Fill the NA's with random values
              prev = prev.fillna(pd.DataFrame(random_state.randn(*np.isnan(prev).shape),
                                              index=members, columns=['x', 'y']))
              init = prev.as_matrix()
              
          # Compute the embedding using the SMACOF algorithm
          positions = smacof(D, weights=W, init=init, random_state=random_state)
      
      elif method == 'sklearn':
          D[np.isnan(D)] = D[~np.isnan(D)].max().max()
          positions = MDS(dissimilarity='precomputed', random_state=random_state).fit_transform(D)
      
      else:
          raise ValueError("method not recognized")
      
      # Return a dataframe of 2d coordinates associated to each member
      return pd.DataFrame(
          positions,
          index=members,
          columns=['x', 'y']
      ).rename_axis('member')
  # 다차원 scaling을 통해 member에 대한 2D 임베딩을 계산합니다.
  
  def members_2d_embedding_with_beacons(m2m, m2b, beacons_position, prev=None, m2m_weight=1., m2b_weight=1.,
                                        P=-61.5, n=2.6, random_state=None):
      """
      매개 변수
      ----------
      m2m : pd.데이터프레임
          'rssi' 열을 사용하여 'datetime', 'member1', 'member2'로 인덱싱된 회원간 근접 데이터,
          
      m2b : pd.데이터프레임
          'rssi' 열을 사용하여 'datetime', 'member', 'beacon'으로 색인화된 회원간 근접 데이터,
          
      beacons_position : pd.데이터프레임
          열 'x'와 'y'가 있는 'beacon'으로 색인화된 각 비콘의 위치.
          
      prev : 없음 또는 pd.데이터프레임
          없음이 아닌 경우 이 함수에 의해 반환된 멤버의 위치입니다.  
          이것은 이전에 계산된 MDS의 값으로 MDS를 초기화하는 데 사용할 수 있다(예: 시계열을 만드는 것).  
          기본값은 없음입니다.
      
      m2m_weight : float
  
      m2b_weight : float
          SMACOF 알고리즘에서 멤버 대 멤버(멤버 대 비콘의 상대적인) 거리에 부여할 가중치.  
          가중치가 높으면 알고리즘이 해당 거리를 더 잘 존중하도록 노력한다는 것을 의미합니다.  
          기본값은 둘 다 1.입니다.
      
      P : 플로트
      n : 플로트
          'rssi_to_distance'에 대한 매개 변수입니다.  
          기본값은 'rssi_to_distance'입니다.
  
      random_state : 없음, int 또는 np.random.RandomState 임베딩을 계산할 때 sklearn이 사용하는 시드/RNG입니다.  기본값은 없음입니다.
      
      return
      -------
      데이터 프레임:
      각 부재의 (x, y) 좌표입니다.
      """
      
      # Initialize the RNG
      if type(random_state) != np.random.RandomState:
          random_state = np.random.RandomState(random_state)
      
      # The list of members
      members = sorted(list(set(list(m2m.reset_index()['member1']) + list(m2m.reset_index()['member2']))))
      # The list of beacons
      beacons = sorted(list(set(m2b.reset_index()['beacon'])))
  
      # Beacon-to-beacon
      distances = coords_to_distance(beacons_position)
      
      # Member-to-member
      df = rssi_to_distance(m2m['rssi'], P=P, n=n).groupby(['member1', 'member2']).mean()
      df = df.append(df.reorder_levels([1, 0]))
      distances = distances.append(df)
      
      # Member-to-beacon
      df = rssi_to_distance(m2b['rssi'], P=P, n=n).groupby(['member', 'beacon']).mean()
      df = df.append(df.reorder_levels([1, 0]))
      distances = distances.append(df)
      
      # Diagonal
      distances = distances.append(pd.Series(np.zeros(len(members)), 
                         index=pd.MultiIndex.from_tuples(zip(members, members))))
      
      # Remove duplicates, in case there are any (there shouldn't be)
      distances = distances[~distances.index.duplicated(keep='first')]
      
      # Distance matrix
      dist_matrix = distances.unstack()
      
      # This is to deal with a "bug/feature" in pd
      # Using .loc on a DF that has non-int indexes will call .iloc internally, which is not what we want
      # Converting the indexes to a string fixes the problem
      dist_matrix.columns = dist_matrix.columns.astype(str)
      dist_matrix.index = dist_matrix.index.astype(str)
      
      # Convert into a numpy matrix, with the rows/columns containing
      # the members first and the beacons second
      D = dist_matrix.loc[map(str, members + beacons), map(str, members + beacons)].as_matrix()
      
      # The weight matrix is set to 0. for missing values, and 1. everywhere else
      W = 1 - np.isnan(D)
      
      m = len(members)
      # Custom weight for member-to-member
      W[m:,m:] = m2m_weight * W[m:,m:]
      # Custom weight for member-to-beacon
      W[m:,:m] = m2b_weight * W[m:,:m]
      W[:m,m:] = m2b_weight * W[:m,m:]
  
      # Missing values in `D`
      D[np.isnan(D)] = 0.0  # Arbitrary value; those distances are ignored anyway
      
      # The position of the anchors
      A = beacons_position.loc[beacons].as_matrix()
      
      init = None
      # If previous values were given for the members positions
      if prev is not None:
          # Select those that match our list of members
          prev = prev.loc[members]
          # Fill the NA's with random values
          prev = prev.fillna(pd.DataFrame(random_state.randn(*np.isnan(prev).shape),
                                          index=members, columns=['x', 'y']))
          init = prev.as_matrix()
          
      # Compute the embedding using the SMACOF algorithm
      positions = smacof(D, weights=W, init=init, anchors=A, random_state=random_state)
      
      # Return a dataframe of 2d coordinates associated to each member
      return pd.DataFrame(
          positions,
          index=members,
          columns=['x', 'y']
      ).rename_axis('member')
  # 집계된 거리와 비콘 데이터를 사용하여 부재의 2D 임베딩을 계산합니다.
  
  