tada

House/asgi.py

@@ -0,0 +1,16 @@
+"""
+ASGI config for House project.
+
+It exposes the ASGI callable as a module-level variable named ``application``.
+
+For more information on this file, see
+https://docs.djangoproject.com/en/3.0/howto/deployment/asgi/
+"""
+
+import os
+
+from django.core.asgi import get_asgi_application
+
+os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'House.settings')
+
+application = get_asgi_application()

House/settings.py

@@ -0,0 +1,127 @@
+"""
+Django settings for House project.
+
+Generated by 'django-admin startproject' using Django 3.0.2.
+
+For more information on this file, see
+https://docs.djangoproject.com/en/3.0/topics/settings/
+
+For the full list of settings and their values, see
+https://docs.djangoproject.com/en/3.0/ref/settings/
+"""
+
+import os
+
+# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+
+# Quick-start development settings - unsuitable for production
+# See https://docs.djangoproject.com/en/3.0/howto/deployment/checklist/
+
+# SECURITY WARNING: keep the secret key used in production secret!
+SECRET_KEY = 'y&ol628+upm0r&=8pilr@u_w_0ji!1afp!st*y#ympn3u@!3s%'
+
+# SECURITY WARNING: don't run with debug turned on in production!
+DEBUG = True
+
+ALLOWED_HOSTS = []
+
+
+# Application definition
+
+INSTALLED_APPS = [
+    'django.contrib.admin',
+    'django.contrib.auth',
+    'django.contrib.contenttypes',
+    'django.contrib.sessions',
+    'django.contrib.messages',
+    'django.contrib.staticfiles',
+]
+
+MIDDLEWARE = [
+    'django.middleware.security.SecurityMiddleware',
+    'django.contrib.sessions.middleware.SessionMiddleware',
+    'django.middleware.common.CommonMiddleware',
+    'django.middleware.csrf.CsrfViewMiddleware',
+    'django.contrib.auth.middleware.AuthenticationMiddleware',
+    'django.contrib.messages.middleware.MessageMiddleware',
+    'django.middleware.clickjacking.XFrameOptionsMiddleware',
+]
+
+ROOT_URLCONF = 'House.urls'
+
+TEMPLATES = [
+    {
+        'BACKEND': 'django.template.backends.django.DjangoTemplates',
+        'DIRS': [os.path.join(BASE_DIR, 'templates')]
+        ,
+        'APP_DIRS': True,
+        'OPTIONS': {
+            'context_processors': [
+                'django.template.context_processors.debug',
+                'django.template.context_processors.request',
+                'django.contrib.auth.context_processors.auth',
+                'django.contrib.messages.context_processors.messages',
+            ],
+        },
+    },
+]
+
+WSGI_APPLICATION = 'House.wsgi.application'
+
+
+# Database
+# https://docs.djangoproject.com/en/3.0/ref/settings/#databases
+
+DATABASES = {
+    'default': {
+        'ENGINE': 'django.db.backends.sqlite3',
+        'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
+    }
+}
+
+
+# Password validation
+# https://docs.djangoproject.com/en/3.0/ref/settings/#auth-password-validators
+
+AUTH_PASSWORD_VALIDATORS = [
+    {
+        'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
+    },
+    {
+        'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
+    },
+    {
+        'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
+    },
+    {
+        'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
+    },
+]
+
+
+# Internationalization
+# https://docs.djangoproject.com/en/3.0/topics/i18n/
+
+LANGUAGE_CODE = 'en-us'
+
+TIME_ZONE = 'UTC'
+
+USE_I18N = True
+
+USE_L10N = True
+
+USE_TZ = True
+
+
+# Static files (CSS, JavaScript, Images)
+# https://docs.djangoproject.com/en/3.0/howto/static-files/
+
+STATIC_URL = '/static/'
+HERE = os.path.dirname(os.path.abspath(__file__))
+HERE = os.path.join(HERE, '../')
+STATICFILES_DIRS = (
+    os.path.join(HERE, 'static/'),
+)
+ALLOWED_HOSTS = ['*']

House/urls.py

@@ -0,0 +1,37 @@
+"""House URL Configuration
+
+The `urlpatterns` list routes URLs to views. For more information please see:
+    https://docs.djangoproject.com/en/3.0/topics/http/urls/
+Examples:
+Function views
+    1. Add an import:  from my_app import views
+    2. Add a URL to urlpatterns:  path('', views.home, name='home')
+Class-based views
+    1. Add an import:  from other_app.views import Home
+    2. Add a URL to urlpatterns:  path('', Home.as_view(), name='home')
+Including another URLconf
+    1. Import the include() function: from django.urls import include, path
+    2. Add a URL to urlpatterns:  path('blog/', include('blog.urls'))
+"""
+from django.contrib import admin
+from django.urls import path
+
+from Houseweb import views
+
+urlpatterns = [
+    # path('admin/', admin.site.urls),
+    path('index/LoadTestBoundary', views.LoadTestBoundary),
+    path('index/NumSearch/', views.NumSearch),
+    path(r'index/LoadTrainHouse/', views.LoadTrainHouse),
+    path(r'index/TransGraph/', views.TransGraph),
+    path(r'index/TransGraph_net/', views.TransGraph_net),
+    path(r'index/Init/', views.Init),
+    path(r'index/AdjustGraph/', views.AdjustGraph),
+    path(r'index/GraphSearch/', views.GraphSearch),
+    path(r'index/RelBox/', views.RelBox),
+    path(r'index/Save_Editbox/', views.Save_Editbox),
+
+    path('home', views.home),
+
+
+]

House/wsgi.py

@@ -0,0 +1,16 @@
+"""
+WSGI config for House project.
+
+It exposes the WSGI callable as a module-level variable named ``application``.
+
+For more information on this file, see
+https://docs.djangoproject.com/en/3.0/howto/deployment/wsgi/
+"""
+
+import os
+
+from django.core.wsgi import get_wsgi_application
+
+os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'House.settings')
+
+application = get_wsgi_application()

Houseweb/admin.py

@@ -0,0 +1,3 @@
+from django.contrib import admin
+
+# Register your models here.

Houseweb/apps.py

@@ -0,0 +1,5 @@
+from django.apps import AppConfig
+
+
+class HousewebConfig(AppConfig):
+    name = 'Houseweb'

Houseweb/models.py

@@ -0,0 +1,3 @@
+from django.db import models
+
+# Create your models here.

Houseweb/tests.py

@@ -0,0 +1,3 @@
+from django.test import TestCase
+
+# Create your tests here.

Houseweb/views.py

@@ -0,0 +1,757 @@
+from django.shortcuts import render
+from django.http import HttpResponse, JsonResponse
+import json
+import model.test as mltest
+import model.utils as mdul
+from model.floorplan import *
+import retrieval.retrieval as rt
+import time
+import pickle
+import scipy.io as sio
+import numpy as np
+from model.decorate import *
+import math
+import pandas as pd
+import matlab.engine
+
+global test_data, test_data_topk, testNameList, trainNameList
+global train_data, trainNameList, trainTF, train_data_eNum, train_data_rNum
+global engview, model
+global tf_train, centroids, clusters
+
+
+def home(request):
+    return render(request, "home.html", )
+
+
+def Init(request):
+    start = time.clock()
+    getTestData()
+    getTrainData()
+    loadMatlabEng()
+    loadModel()
+    loadRetrieval()
+    end = time.clock()
+    print('Init(model+test+train+engine+retrieval) time: %s Seconds' % (end - start))
+
+    return HttpResponse(None)
+
+
+def loadMatlabEng():
+    startengview = time.clock()
+    global engview
+    engview = matlab.engine.start_matlab()
+    engview.addpath(r'./align_fp/', nargout=0)
+    endengview = time.clock()
+    print(' matlab.engineview time: %s Seconds' % (endengview - startengview))
+
+
+def loadRetrieval():
+    global tf_train, centroids, clusters
+    t1 = time.clock()
+    tf_train = np.load('./retrieval/tf_train.npy')
+    centroids = np.load('./retrieval/centroids_train.npy')
+    clusters = np.load('./retrieval/clusters_train.npy')
+    t2 = time.clock()
+    print('load tf/centroids/clusters', t2 - t1)
+
+
+def getTestData():
+    start = time.clock()
+    global test_data, testNameList, trainNameList
+ 
+    test_data = pickle.load(open('./static/Data/data_test_converted.pkl', 'rb'))
+    test_data, testNameList, trainNameList = test_data['data'], list(test_data['testNameList']), list(
+        test_data['trainNameList'])
+    end = time.clock()
+    print('getTestData time: %s Seconds' % (end - start))
+
+
+def getTrainData():
+    start = time.clock()
+    global train_data, trainNameList, trainTF, train_data_eNum, train_data_rNum
+    
+    train_data = pickle.load(open('./static/Data/data_train_converted.pkl', 'rb'))
+    train_data, trainNameList, trainTF = train_data['data'], list(train_data['nameList']), list(train_data['trainTF'])
+    
+    train_data_eNum = pickle.load(open('./static/Data/data_train_eNum.pkl', 'rb'))
+    train_data_eNum = train_data_eNum['eNum']
+    train_data_rNum = np.load('./static/Data/rNum_train.npy')
+
+    end = time.clock()
+    print('getTrainData time: %s Seconds' % (end - start))
+
+
+def loadModel():
+    global model, train_data, trainNameList
+    start = time.clock()
+    model = mltest.load_model()
+    end = time.clock()
+    print('loadModel time: %s Seconds' % (end - start))
+    start = time.clock()
+    test = train_data[trainNameList.index("75119")]
+    mltest.test(model, FloorPlan(test, train=True))
+    end = time.clock()
+    print('test Model time: %s Seconds' % (end - start))
+
+
+def LoadTestBoundary(request):
+    start = time.clock()
+    testName = request.GET.get('testName').split(".")[0]
+    test_index = testNameList.index(testName)
+    data = test_data[test_index]
+    data_js = {}
+    data_js["door"] = str(data.boundary[0][0]) + "," + str(data.boundary[0][1]) + "," + str(
+        data.boundary[1][0]) + "," + str(data.boundary[1][1])
+    ex = ""
+    for i in range(len(data.boundary)):
+        ex = ex + str(data.boundary[i][0]) + "," + str(data.boundary[i][1]) + " "
+    data_js['exterior'] = ex
+    end = time.clock()
+    print('LoadTestBoundary time: %s Seconds' % (end - start))
+    return HttpResponse(json.dumps(data_js), content_type="application/json")
+
+
+def get_filter_func(mask, acc, num):
+    filters = [
+        None if not mask else (
+            np.equal if acc[i] else np.greater_equal
+        )
+        for i in range(len(mask))
+    ]
+
+    def filter_func(data):
+        for i in range(len(filters)):
+            if (filters[i] is not None) and (not filters[i](data[i], num[i])): return False
+        return True
+
+    return filter_func
+
+
+def filter_graph(graph_):
+    filters = graph_
+
+    def filter_graphfunc(data):
+        sub = data - filters
+        return ((sub >= 0).all())
+
+    return filter_graphfunc
+
+
+def NumSearch(request):
+    start = time.clock()
+    data_new = json.loads(request.GET.get("userInfo"))
+    testName = data_new[0].split(".")[0]
+    test_index = testNameList.index(testName)
+    topkList = []
+    topkList.clear()
+    data = test_data[test_index]
+
+   
+    multi_clusters=False
+    test_data_topk = rt.retrieval(data, 1000,multi_clusters)
+    
+    if len(data_new) > 1:
+        roomactarr = data_new[1]
+        roomexaarr = data_new[2]
+        roomnumarr = [int(x) for x in data_new[3]]
+        
+        test_num = train_data_rNum[test_data_topk]
+        filter_func = get_filter_func(roomactarr, roomexaarr, roomnumarr)
+        indices = np.where(list(map(filter_func, test_num)))
+        indices = list(indices)
+        if len(indices[0]) < 20:
+            topk = len(indices[0])
+        else:
+            topk = 20
+        topkList.clear()
+        for i in range(topk):
+            topkList.append(str(trainNameList[int(test_data_topk[indices[0][i]])]) + ".png")
+    end = time.clock()
+    print('NumberSearch time: %s Seconds' % (end - start))
+    return HttpResponse(json.dumps(topkList), content_type="application/json")
+
+
+def FindTraindata(trainname):
+    start = time.clock()
+    train_index = trainNameList.index(trainname)
+    data = train_data[train_index]
+    data_js = {}
+    data_js["hsname"] = trainname
+
+    data_js["door"] = str(data.boundary[0][0]) + "," + str(data.boundary[0][1]) + "," + str(
+        data.boundary[1][0]) + "," + str(data.boundary[1][1])
+    print("testboundary", data_js["door"])
+    ex = ""
+    for i in range(len(data.boundary)):
+        ex = ex + str(data.boundary[i][0]) + "," + str(data.boundary[i][1]) + " "
+    data_js['exterior'] = ex
+
+    data_js["hsedge"] = [[int(u), int(v)] for u, v in data.edge[:, [0, 1]]]
+
+    hsbox = [[[float(x1), float(y1), float(x2), float(y2)], [mdul.room_label[cate][1]]] for
+             x1, y1, x2, y2, cate in data.box[:]]
+    external = np.asarray(data.boundary)
+    xmin, xmax = np.min(external[:, 0]), np.max(external[:, 0])
+    ymin, ymax = np.min(external[:, 1]), np.max(external[:, 1])
+    
+    area_ = (ymax - ymin) * (xmax - xmin)
+    
+    data_js["rmsize"] = [
+        [[20 * math.sqrt((float(x2) - float(x1)) * (float(y2) - float(y1)) / float(area_))], [mdul.room_label[cate][1]]]
+        for
+        x1, y1, x2, y2, cate in data.box[:]]
+   
+
+    box_order = data.order
+    data_js["hsbox"] = []
+    for i in range(len(box_order)):
+        data_js["hsbox"].append(hsbox[int(float(box_order[i])) - 1])
+
+    data_js["rmpos"] = [[int(cate), str(mdul.room_label[cate][1]), float((x1 + x2) / 2), float((y1 + y2) / 2)] for
+                        x1, y1, x2, y2, cate in data.box[:]]
+    end = time.clock()
+    print('find train data time: %s Seconds' % (end - start))
+    return data_js
+
+
+def LoadTrainHouse(request):
+    trainname = request.GET.get("roomID").split(".")[0]
+    data_js = FindTraindata(trainname)
+    return HttpResponse(json.dumps(data_js), content_type="application/json")
+
+
+'''
+ transfer the graph of the training data into the graph of the test data
+'''
+
+
+def TransGraph(request):
+    start = time.clock()
+    userInfo = request.GET.get("userInfo")
+    testname = userInfo.split(',')[0]
+    trainname = request.GET.get("roomID")
+    mlresult = mltest.get_userinfo(testname, trainname)
+
+    fp_end = mlresult
+   
+    sio.savemat("./static/" + userInfo.split(',')[0].split('.')[0] + ".mat", {"data": fp_end.data})
+
+    data_js = {}
+    # fp_end  hsedge
+    data_js["hsedge"] = (fp_end.get_triples(tensor=False)[:, [0, 2, 1]]).astype(np.float).tolist()
+
+    # fp_rmsize
+    external = np.asarray(fp_end.data.boundary)
+    xmin, xmax = np.min(external[:, 0]), np.max(external[:, 0])
+    ymin, ymax = np.min(external[:, 1]), np.max(external[:, 1])
+    area_ = (ymax - ymin) * (xmax - xmin)
+    data_js["rmsize"] = [
+        [[20 * math.sqrt((float(x2) - float(x1)) * (float(y2) - float(y1)) / float(area_))], [mdul.room_label[cate][1]]]
+        for
+        x1, y1, x2, y2, cate in fp_end.data.box[:]]
+    # fp_end rmpos
+
+    rooms = fp_end.get_rooms(tensor=False)
+
+    
+    center = [[(x1 + x2) / 2, (y1 + y2) / 2] for x1, y1, x2, y2 in fp_end.data.box[:, :4]]
+
+    # boxes_pred
+    data_js["rmpos"] = []
+    for k in range(len(center)):
+        node = float(rooms[k]), mdul.room_label[int(rooms[k])][1], center[k][0], center[k][1], float(k)
+        data_js["rmpos"].append(node)
+
+    test_index = testNameList.index(testname.split(".")[0])
+    data = test_data[test_index]
+    ex = ""
+    for i in range(len(data.boundary)):
+        ex = ex + str(data.boundary[i][0]) + "," + str(data.boundary[i][1]) + " "
+    data_js['exterior'] = ex
+    data_js["door"] = str(data.boundary[0][0]) + "," + str(data.boundary[0][1]) + "," + str(
+        data.boundary[1][0]) + "," + str(data.boundary[1][1])
+    end = time.clock()
+    print('TransGraph time: %s Seconds' % (end - start))
+    return HttpResponse(json.dumps(data_js), content_type="application/json")
+
+
+def AdjustGraph(request):
+    start = time.clock()
+    # newNode index-typename-cx-cy
+    # oldNode index-typename-cx-cy
+    # newEdge u-v
+    NewGraph = json.loads(request.GET.get("NewGraph"))
+    testname = request.GET.get("userRoomID")
+    trainname = request.GET.get("adptRoomID")
+    s = time.clock()
+    mlresult = mltest.get_userinfo_adjust(testname, trainname, NewGraph)
+    e = time.clock()
+    print('get_userinfo_adjust: %s Seconds' % (e - s))
+    fp_end = mlresult[0]
+    global boxes_pred
+    boxes_pred = mlresult[1]
+    
+    data_js = {}
+    data_js["hsedge"] = (fp_end.get_triples(tensor=False)[:, [0, 2, 1]]).astype(np.float).tolist()
+  
+    rooms = fp_end.get_rooms(tensor=False)
+    center = [[(x1 + x2) / 2, (y1 + y2) / 2] for x1, y1, x2, y2 in fp_end.data.box[:, :4]]
+
+    box_order = mlresult[2]
+    '''
+    handle the information of the room boxes 
+    boxes_pred: the prediction from net
+    box_order: The order in which boxes are drawn
+
+    '''
+    room = []
+    for o in range(len(box_order)):
+        room.append(float((rooms[int(float(box_order[o][0])) - 1])))
+    boxes_end = []
+    for i in range(len(box_order)):
+        tmp = []
+        for j in range(4):
+            tmp.append(float(boxes_pred[int(float(box_order[i][0])) - 1][j]))
+        boxes_end.append(tmp)
+    
+    data_js['roomret'] = []
+    for k in range(len(room)):
+        data = boxes_end[k], [mdul.room_label[int(room[k])][1]], box_order[k][0] - 1
+        data_js['roomret'].append(data)
+    
+    # change the box size
+    global relbox
+    relbox = data_js['roomret']
+    global reledge
+    reledge = data_js["hsedge"]
+
+    test_index = testNameList.index(testname.split(".")[0])
+    data = test_data[test_index]
+    ex = ""
+    for i in range(len(data.boundary)):
+        ex = ex + str(data.boundary[i][0]) + "," + str(data.boundary[i][1]) + " "
+    data_js['exterior'] = ex
+    data_js["door"] = str(data.boundary[0][0]) + "," + str(data.boundary[0][1]) + "," + str(
+        data.boundary[1][0]) + "," + str(data.boundary[1][1])
+
+    external = np.asarray(data.boundary)
+    xmin, xmax = np.min(external[:, 0]), np.max(external[:, 0])
+    ymin, ymax = np.min(external[:, 1]), np.max(external[:, 1])
+    area_ = (ymax - ymin) * (xmax - xmin)
+    data_js['rmsize'] = []
+    for i in range(len(data_js['roomret'])):
+        rmsize = 20 * math.sqrt((float(data_js['roomret'][i][0][2]) - float(data_js['roomret'][i][0][0])) * (
+                float(data_js['roomret'][i][0][3]) - float(data_js['roomret'][i][0][1])) / float(area_)), \
+                 data_js["roomret"][i][1][0]
+        data_js["rmsize"].append(rmsize)
+
+    data_js["rmpos"] = []
+
+    newGraph = NewGraph[0]
+    for i in range(len(data_js['roomret'])):
+        for k in range(len(newGraph)):
+            if (data_js['roomret'][i][1][0] == newGraph[k][1]):
+                x_center = int((data_js['roomret'][i][0][0] + data_js['roomret'][i][0][2]) / 2)
+                y_center = int((data_js['roomret'][i][0][1] + data_js['roomret'][i][0][3]) / 2)
+                x_graph = newGraph[k][2]
+                y_graph = newGraph[k][3]
+                if ((int(x_graph - 30) < x_center < int(x_graph + 30))):
+                    node = float(rooms[k]), newGraph[k][1], x_center, y_center, float(
+                        newGraph[k][0])
+                    data_js["rmpos"].append(node)
+                    newGraph.pop(k)
+                    break
+                if ((int(y_graph - 30) < y_center < int(y_graph + 30))):
+                    node = float(rooms[k]), newGraph[k][1], x_center, y_center, float(
+                        newGraph[k][0])
+                    data_js["rmpos"].append(node)
+                    newGraph.pop(k)
+
+                    break
+    
+    fp_end.data = add_dw_fp(fp_end.data)
+    data_js["indoor"] = []
+    
+    boundary = data.boundary
+    
+    isNew = boundary[:, 3]
+    frontDoor = boundary[[0, 1]]  
+    frontDoor = frontDoor[:, [0, 1]]  
+    frontsum = frontDoor.sum(axis=1).tolist()
+    idx = frontsum.index(min(frontsum))
+    wallThickness = 3
+    if idx == 1:
+        frontDoor = frontDoor[[1, 0], :]
+    orient = boundary[0][2]
+    if orient == 0 or orient == 2:
+        frontDoor[0][0] = frontDoor[0][0] + wallThickness / 4
+        frontDoor[1][0] = frontDoor[1][0] - wallThickness / 4
+    if orient == 1 or orient == 3:
+        frontDoor[0][1] = frontDoor[0][1] + wallThickness / 4
+        frontDoor[1][1] = frontDoor[1][1] - wallThickness / 4
+    
+
+    data_js["windows"] = []
+    for indx, x, y, w, h, r in fp_end.data.windows:
+        if w != 0:
+            tmp = [x + 2, y - 2, w - 2, 4]
+            data_js["windows"].append(tmp)
+        if h != 0:
+            tmp = [x - 2, y, 4, h]
+            data_js["windows"].append(tmp)
+    data_js["windowsline"] = []
+    for indx, x, y, w, h, r in fp_end.data.windows:
+        if w != 0:
+            tmp = [x + 2, y, w + x, y]
+            data_js["windowsline"].append(tmp)
+        if h != 0:
+            tmp = [x, y, x, h + y]
+            data_js["windowsline"].append(tmp)
+    
+    sio.savemat("./static/" + testname.split(',')[0].split('.')[0] + ".mat", {"data": fp_end.data})
+
+    end = time.clock()
+    print('AdjustGraph time: %s Seconds' % (end - start))
+    return HttpResponse(json.dumps(data_js), content_type="application/json")
+
+
+def RelBox(request):
+    id = request.GET.get("selectRect")
+    print(id)
+    global relbox
+    global reledge
+    rdirgroup=get_dir(id,relbox,reledge)
+    return HttpResponse(json.dumps(rdirgroup), content_type="application/json")
+
+def get_dir(id,relbox,reledge):
+    rel = []
+    selectindex = int(id.split("_")[1])
+    select = np.zeros(4).astype(int)
+    for i in range(len(relbox)):
+        a = math.ceil(relbox[i][0][0]), math.ceil(relbox[i][0][1]), math.ceil(relbox[i][0][2]), math.ceil(
+            relbox[i][0][3]), int(relbox[i][2])
+        rel.append(a)
+        if (selectindex == int(relbox[i][2])):
+            # select:x1,x0,y0,y1.relbox:x0,y0,x1,y1
+            select[0] = math.ceil(relbox[i][0][2])
+            select[1] = math.ceil(relbox[i][0][0])
+            select[2] = math.ceil(relbox[i][0][1])
+            select[3] = math.ceil(relbox[i][0][3])
+    rel = np.array(rel)
+    df = pd.DataFrame({'x0': rel[:, 0], 'y0': rel[:, 1], 'x1': rel[:, 2], 'y1': rel[:, 3], 'rindex': rel[:, 4]})
+    group_label = [(0, 'x1', "right"),
+                   (1, 'x0', "left"),
+                   (2, 'y0', "top"),
+                   (3, 'y1', "down")]
+    dfgroup = []
+    for i in range(len(group_label)):
+        dfgroup.append(df.groupby(group_label[i][1], as_index=True).get_group(name=select[i]))
+    rdirgroup = []
+    for i in range(len(dfgroup)):
+        dir = dfgroup[i]
+        rdir = []
+        for k in range(len(dir)):
+            idx = (dir.loc[dir['rindex'] == (dir.iloc[[k]].values)[0][4]].index.values)[0]
+            rdir.append(relbox[idx][1][0].__str__() + "_" + (dir.iloc[[k]].values)[0][4].__str__())
+        rdirgroup.append(rdir)
+    reledge = np.array(reledge)
+    data1 = reledge[np.where((reledge[:, [0]] == selectindex))[0]]
+    data2 = reledge[np.where((reledge[:, [1]] == selectindex))[0]]
+    reledge1 = np.vstack((data1, data2))
+    return rdirgroup
+def Save_Editbox(request):
+    global indxlist,boxes_pred
+    NewGraph = json.loads(request.GET.get("NewGraph"))
+    NewLay = json.loads(request.GET.get("NewLay"))
+    userRoomID = request.GET.get("userRoomID")
+    adptRoomID = request.GET.get("adptRoomID")
+    
+    NewLay=np.array(NewLay)
+    NewLay=NewLay[np.argsort(NewLay[:, 1])][:,2:]
+    NewLay=NewLay.astype(float).tolist()
+
+    test_index = testNameList.index(userRoomID.split(".")[0])
+    test_ = test_data[test_index]
+    
+    Boundary = test_.boundary
+    boundary=[[float(x),float(y),float(z),float(k)] for x,y,z,k in list(Boundary)]
+    test_fp =FloorPlan(test_)
+
+    train_index = trainNameList.index(adptRoomID.split(".")[0])
+    train_ =train_data[train_index]
+    train_fp =FloorPlan(train_,train=True)
+    fp_end = test_fp.adapt_graph(train_fp)
+    fp_end.adjust_graph()
+    newNode = NewGraph[0]
+    newEdge = NewGraph[1]
+    oldNode = NewGraph[2]
+    temp = []
+    for newindx, newrmname, newx, newy,scalesize in newNode:
+        for type, oldrmname, oldx, oldy, oldindx in oldNode:
+            if (int(newindx) == oldindx):
+                tmp=int(newindx), (newx - oldx), ( newy- oldy),float(scalesize)
+                temp.append(tmp)
+    newbox=[]
+    if mltest.adjust==True:
+        oldbox = []
+        for i in range(len(boxes_pred)):
+            indxtmp=[boxes_pred[i][0],boxes_pred[i][1],boxes_pred[i][2],boxes_pred[i][3],boxes_pred[i][0]]
+            oldbox.append(indxtmp)
+    if mltest.adjust==False:
+        indxlist=[]
+        oldbox=fp_end.data.box.tolist()
+        for i in range(len(oldbox)):
+            indxlist.append([oldbox[i][4]])
+        indxlist=np.array(indxlist)
+        adjust=True
+    oldbox=fp_end.data.box.tolist()
+    X=0
+    Y=0
+    for i in range(len(oldbox)):
+        X= X+(oldbox[i][2]-oldbox[i][0])
+        Y= Y+(oldbox[i][3]-oldbox[i][1])
+    x_ave=(X/len(oldbox))/2
+    y_ave=(Y/len(oldbox))/2
+
+    index_mapping = {}
+    #  The room that already exists
+    #  Move: Just by the distance
+    for newindx, tempx, tempy,scalesize in temp:
+        index_mapping[newindx] = len(newbox)
+        tmpbox=[]
+        scalesize = int(scalesize)
+        if scalesize<1:
+            scale = math.sqrt(scalesize)
+            scalex = (oldbox[newindx][2] - oldbox[newindx][0]) * (1 - scale) / 2
+            scaley = (oldbox[newindx][3] - oldbox[newindx][1]) * (1 - scale) / 2
+            tmpbox = [(oldbox[newindx][0] + tempx) + scalex, (oldbox[newindx][1] + tempy)+scaley,
+                      (oldbox[newindx][2] + tempx) - scalex, (oldbox[newindx][3] + tempy) - scaley, oldbox[newindx][4]]
+        if scalesize == 1:
+            tmpbox = [(oldbox[newindx][0] + tempx) , (oldbox[newindx][1] + tempy) ,(oldbox[newindx][2] + tempx), (oldbox[newindx][3] + tempy), oldbox[newindx][4]]
+
+        if scalesize>1:
+            scale=math.sqrt(scalesize)
+            scalex = (oldbox[newindx][2] - oldbox[newindx][0]) * ( scale-1) / 2
+            scaley = (oldbox[newindx][3] - oldbox[newindx][1]) * (scale-1) / 2
+            tmpbox = [(oldbox[newindx][0] + tempx) - scalex, (oldbox[newindx][1] + tempy) - scaley,
+                      (oldbox[newindx][2] + tempx) + scalex, (oldbox[newindx][3] + tempy) + scaley, oldbox[newindx][4]]
+
+        newbox.append(tmpbox)
+
+    #  The room just added
+    #  Move: The room node with the average size of the existing room
+    for newindx, newrmname, newx, newy,scalesize in newNode:
+        if int(newindx)>(len(oldbox)-1):
+            scalesize=int(scalesize)
+            index_mapping[int(newindx)] = (len(newbox))
+            tmpbox=[]
+            if scalesize < 1:
+                scale = math.sqrt(scalesize)
+                scalex = x_ave * (1 - scale) / 2
+                scaley = y_ave* (1 - scale) / 2
+                tmpbox = [(newx-x_ave) +scalex,(newy-y_ave) +scaley,(newx+x_ave)-scalex,(newy+y_ave)-scaley,vocab['object_name_to_idx'][newrmname]]
+
+            if scalesize == 1:
+                tmpbox = [(newx - x_ave), (newy - y_ave), (newx + x_ave), (newy + y_ave),vocab['object_name_to_idx'][newrmname]]
+            if scalesize > 1:
+                scale = math.sqrt(scalesize)
+                scalex = x_ave * (scale - 1) / 2
+                scaley = y_ave * (scale - 1) / 2
+                tmpbox = [(newx-x_ave) - scalex, (newy-y_ave)  - scaley,(newx+x_ave) + scalex, (newy+y_ave) + scaley,vocab['object_name_to_idx'][newrmname]]
+            # tmpboxin = [(newx-x_ave) ,(newy-y_ave) ,(newx+x_ave) ,(newy+y_ave) ,vocab['object_name_to_idx'][newrmname]]
+            # print(tmpboxin)
+            # print(tmpbox)
+            # print(scalesize)
+            newbox.append(tmpbox)
+
+    fp_end.data.box=np.array(newbox)
+    
+    adjust_Edge=[]
+    for u, v in newEdge:
+        tmp=[index_mapping[int(u)],index_mapping[int(v)], 0]
+        adjust_Edge.append(tmp)
+    fp_end.data.edge=np.array(adjust_Edge)
+    rType = fp_end.get_rooms(tensor=False)
+
+    rEdge = fp_end.get_triples(tensor=False)[:, [0, 2, 1]]
+    Edge = [[float(u), float(v), float(type2)] for u, v, type2 in rEdge]
+    Box=NewLay
+    boundary_mat = matlab.double(boundary)
+    rType_mat = matlab.double(rType.tolist())
+    Edge_mat = matlab.double(Edge)
+    Box_mat=matlab.double(Box)
+    fp_end.data.boundary =np.array(boundary)
+    fp_end.data.rType =np.array(rType).astype(int)
+    fp_end.data.refineBox=np.array(Box)
+    fp_end.data.rEdge=np.array(Edge)
+
+    box_refine = engview.align_fp(boundary_mat, Box_mat,  rType_mat,Edge_mat ,18,False, nargout=3)
+    box_out=box_refine[0]
+    box_order=box_refine[1]
+    rBoundary=box_refine[2]
+    fp_end.data.newBox = np.array(box_out)
+    fp_end.data.order = np.array(box_order)
+    fp_end.data.rBoundary = [np.array(rb) for rb in rBoundary]
+    fp_end.data = add_dw_fp(fp_end.data)
+    sio.savemat("./static/" + userRoomID + ".mat", {"data": fp_end.data})
+    flag=1
+    return HttpResponse(json.dumps(flag), content_type="application/json")
+
+
+def TransGraph_net(request):
+    userInfo = request.GET.get("userInfo")
+    testname = userInfo.split(',')[0]
+    trainname = request.GET.get("roomID")
+    mlresult = mltest.get_userinfo_net(testname, trainname)
+
+    fp_end = mlresult[0]
+    boxes_pred = mlresult[1]
+
+    data_js = {}
+    # fp_end  hsedge
+    data_js["hsedge"] = (fp_end.get_triples(tensor=False)[:, [0, 2, 1]]).astype(np.float).tolist()
+
+    # fp_end rmpos
+    rooms = fp_end.get_rooms(tensor=False)
+    room = rooms
+    center = [[(x1 + x2) / 2, (y1 + y2) / 2] for x1, y1, x2, y2 in fp_end.data.box[:, :4]]
+
+    
+
+    # boxes_pred
+    data_js["rmpos"] = []
+    for k in range(len(center)):
+        node = float(room[k]), mdul.room_label[int(room[k])][1], center[k][0], center[k][1]
+        data_js["rmpos"].append(node)
+    boxes_end = boxes_pred.tolist()
+    data_js['roomret'] = []
+    for k in range(len(room)):
+        data = boxes_end[k], [mdul.room_label[int(room[k])][1]]
+        data_js['roomret'].append(data)
+
+    test_index = testNameList.index(testname.split(".")[0])
+    data = test_data[test_index]
+    ex = ""
+    for i in range(len(data.boundary)):
+        ex = ex + str(data.boundary[i][0]) + "," + str(data.boundary[i][1]) + " "
+    data_js['exterior'] = ex
+    x0, x1 = np.min(data.boundary[:, 0]), np.max(data.boundary[:, 0])
+    y0, y1 = np.min(data.boundary[:, 1]), np.max(data.boundary[:, 1])
+    data_js['bbxarea'] = float((x1 - x0) * (y1 - y0))
+    return HttpResponse(json.dumps(data_js), content_type="application/json")
+
+
+def GraphSearch(request):
+    s=time.clock()
+    # Graph
+    Searchtype = ["BedRoom", "Bathroom", "Kitchen", "Balcony", "Storage"]
+    BedRoomlist = ["MasterRoom", "SecondRoom", "GuestRoom", "ChildRoom", "StudyRoom"]
+    NewGraph = json.loads(request.GET.get("NewGraph"))
+   
+    testname = request.GET.get("userRoomID")
+    newNode = NewGraph[0]
+    newEdge = NewGraph[1]
+    r_Num = np.zeros((1, 14)).tolist()
+    r_Mask = np.zeros((1, 14)).tolist()
+    r_Acc = np.zeros((1, 14)).tolist()
+    r_Num[0][0] = 1
+    r_Mask[0][0] = 1
+    r_Acc[0][0] = 1
+
+    for indx, rmname, x, y, scalesize in newNode:
+        r_Num[0][mdul.vocab['object_name_to_idx'][rmname]] = r_Num[0][mdul.vocab['object_name_to_idx'][rmname]] + 1
+        r_Mask[0][mdul.vocab['object_name_to_idx'][rmname]] = 1
+        if rmname in BedRoomlist:
+            r_Num[0][13] = r_Num[0][13] + 1
+            r_Mask[0][13] = 1
+
+    test_index = testNameList.index(testname.split(".")[0])
+    topkList = []
+    topkList.clear()
+    data = test_data[test_index]
+   
+    Numrooms = json.loads(request.GET.get("Numrooms"))
+    
+
+    roomactarr = Numrooms[0]
+    roomexaarr = Numrooms[1]
+    roomnumarr = [int(x) for x in Numrooms[2]]
+    test_data_topk=np.arange(0,74995)
+
+    if np.sum(roomactarr) != 1 or np.sum(roomexaarr) != 1 or np.sum(roomnumarr) != 1:
+        test_num = train_data_rNum[test_data_topk]
+        # Number filter
+     
+        filter_func = get_filter_func(roomactarr, roomexaarr, roomnumarr)
+        indices = np.where(list(map(filter_func, test_num)))
+        # print("np.where(list(map(fil", test_num)
+        indices = list(indices)
+        test_data_topk = test_data_topk[indices[0]]
+
+    test_num = train_data_eNum[test_data_topk]
+    # Graph filter
+    
+    edgematrix = np.zeros((5, 5))
+    for indx1, indx2 in newEdge:
+        tmp1 = ""
+        tmp2 = ""
+        for indx, rmname, x, y, scalesize in newNode:
+            if indx1 == indx:
+                if rmname in BedRoomlist:
+                    tmp1 = "BedRoom"
+                else:
+                    tmp1 = rmname
+        for indx, rmname, x, y, scalesize in newNode:
+            if indx2 == indx:
+                if rmname in BedRoomlist:
+                    tmp2 = "BedRoom"
+                else:
+                    tmp2 = rmname
+        if tmp1 != "" and tmp2 != "":
+            edgematrix[Searchtype.index(tmp1)][Searchtype.index(tmp2)] = edgematrix[Searchtype.index(tmp1)][
+                                                                             Searchtype.index(tmp2)] + 1
+            edgematrix[Searchtype.index(tmp2)][Searchtype.index(tmp1)] = edgematrix[Searchtype.index(tmp2)][
+                                                                             Searchtype.index(tmp1)] + 1
+    edge = edgematrix.reshape((1, 25))
+    filter_graphfunc = filter_graph(edge)
+    # rNum_list
+    eNumData = []
+   
+    indices = np.where(list(map(filter_graphfunc, test_num)))
+
+    indices = list(indices)
+    tf_trainsub=tf_train[test_data_topk[indices[0]]]
+    re_data = train_data[test_data_topk[indices[0]]]
+    test_data_tftopk=retrieve_bf(tf_trainsub, data, k=20)
+    re_data=re_data[test_data_tftopk]
+    if len(re_data) < 20:
+        topk = len(re_data)
+    else:
+        topk = 20
+    topkList = []
+    for i in range(topk):
+        topkList.append(str(re_data[i].name) + ".png")
+        
+    e=time.clock()
+    print('Graph Search time: %s Seconds' % (e - s))
+
+    print("topkList", topkList)
+    return HttpResponse(json.dumps(topkList), content_type="application/json")
+
+
+def retrieve_bf(tf_trainsub, datum, k=20):
+    # compute tf for the data boundary
+    x, y = rt.compute_tf(datum.boundary)
+    y_sampled = rt.sample_tf(x, y, 1000)
+    dist = np.linalg.norm(y_sampled - tf_trainsub, axis=1)
+    if k > np.log2(len(tf_trainsub)):
+        index = np.argsort(dist)[:k]
+    else:
+        index = np.argpartition(dist, k)[:k]
+        index = index[np.argsort(dist[index])]
+    return index
+
+
+if __name__ == "__main__":
+    pass

align_fp/align_adjacent_room3.m

@@ -0,0 +1,121 @@
+function [newBox, constraint] = align_adjacent_room3(box, tempBox, updated, type, threshold)
+% position of box1 relative to box2
+% 0 left-above
+% 1 left-below
+% 2 left-of
+% 3 above
+% 4 inside
+% 5 surrounding
+% 6 below
+% 7 right-of
+% 8 right-above
+% 9 right-below
+
+
+newBox = box;
+constraint = zeros(4, 2);
+idx = 1;
+
+if type == 0
+    alignV(true);
+    alignH(true);
+elseif type == 1
+    alignV(true);
+    alignH(false);
+elseif type == 2
+    align([2,1], [1,3], threshold);
+    align([2,2], [1,2], threshold/2);
+    align([2,4], [1,4], threshold/2);
+elseif type == 3
+    align([2,2], [1,4], threshold);
+    align([2,1], [1,1], threshold/2);
+    align([2,3], [1,3], threshold/2);
+elseif type == 4
+    align([2,1], [1,1], true);
+    align([2,2], [1,2], true);
+    align([2,3], [1,3], true);
+    align([2,4], [1,4], true);
+elseif type == 5
+    align([1,1], [2,1], true);
+    align([1,2], [2,2], true);
+    align([1,3], [2,3], true);
+    align([1,4], [2,4], true);
+elseif type == 6
+    align([2,4], [1,2], threshold);
+    align([2,1], [1,1], threshold/2);
+    align([2,3], [1,3], threshold/2);
+elseif type == 7
+    align([2,3], [1,1], threshold);
+    align([2,2], [1,2], threshold/2);
+    align([2,4], [1,4], threshold/2);
+elseif type == 8
+    alignV(false);
+    alignH(true);
+elseif type == 9
+    alignV(false);
+    alignH(false);
+end
+
+constraint = constraint(1:idx-1, :);
+
+function alignV(isLeft)
+    if isLeft
+        idx1 = 1;
+        idx2 = 3;
+    else
+        idx1 = 3;
+        idx2 = 1;
+    end
+    
+    if abs(tempBox(2,idx1) - tempBox(1,idx2)) <= abs(tempBox(2,idx2) - tempBox(1,idx2))
+        align([2,idx1], [1,idx2], threshold/2)
+    else
+        align([2,idx2], [1,idx2], threshold/2)
+    end
+end
+
+function alignH(isAbove)
+    if isAbove
+        idx1 = 2;
+        idx2 = 4;
+    else
+        idx1 = 4;
+        idx2 = 2;
+    end
+    
+    if abs(tempBox(2,idx1) - tempBox(1,idx2)) <= abs(tempBox(2,idx2) - tempBox(1,idx2))
+        align([2,idx1], [1,idx2], threshold/2)
+    else
+        align([2,idx2], [1,idx2], threshold/2)
+    end
+end
+
+function align(idx1, idx2, threshold, attach)
+    if nargin < 4
+        attach = false;
+    end
+    if abs(tempBox(idx1(1),idx1(2))- tempBox(idx2(1), idx2(2))) <= threshold    
+        if updated(idx1(1), idx1(2)) && ~updated(idx2(1), idx2(2))
+            newBox(idx2(1), idx2(2)) = newBox(idx1(1),idx1(2));
+        elseif updated(idx2(1), idx2(2)) && ~updated(idx1(1), idx1(2))
+            newBox(idx1(1), idx1(2)) = newBox(idx2(1),idx2(2));
+        elseif ~updated(idx1(1), idx1(2)) && ~updated(idx2(1), idx2(2))
+            if attach
+                newBox(idx2(1), idx2(2)) = newBox(idx1(1),idx1(2));
+            else
+                y = (newBox(idx1(1),idx1(2)) + newBox(idx2(1), idx2(2)))/2;
+                newBox(idx1(1),idx1(2)) = y;
+                newBox(idx2(1), idx2(2)) = y;
+            end
+        end
+        
+        if idx1(1) == 1
+            constraint(idx, :) = [idx1(2) idx2(2)];
+        else
+            constraint(idx, :) = [idx2(2) idx1(2)];
+        end
+        idx = idx + 1;
+    end
+end
+
+end

align_fp/align_fp.m

@@ -0,0 +1,108 @@
+function [newBox, order, rBoundary] = align_fp(boundary, rBox, rType, rEdge, fp, threshold, drawResult)
+% align the neighboring rooms first and then align with the boundary
+
+if nargin < 7
+    drawResult =false;
+end
+
+% pre-processing: 
+% move the edge relation w.r.t. living room to the end
+livingIdx = find(rType==0);
+idx = rEdge(:,1) == livingIdx-1 | rEdge(:,2) == livingIdx-1;
+% a = rEdge(~idx, :);
+% b = rEdge(idx, :);
+% rEdge = [a; b];
+rEdge = rEdge(~idx, :);
+entranceBox = get_entrance_space(boundary(1:2, 1:2), boundary(1,3), threshold);
+
+if drawResult
+    clf
+    subplot(2,2,1)
+    plot_fp(rBox, boundary, rType, entranceBox);
+    title('original');
+end
+
+%% option #1: use greedy method: align with boundary first and then neighbor
+% 1. align with boundary after the neighbors have been aligned
+[~, newBox, updated] = align_with_boundary(rBox, boundary, threshold, rType);
+
+if drawResult
+    subplot(2,2,2)
+    plot_fp(newBox, boundary, rType, entranceBox);
+    title('Align with boundary');
+end
+
+
+% 2. for each adjacent pair of room,
+[~, newBox, ~] = align_neighbor(newBox, rEdge, updated, threshold+6);
+if drawResult
+    subplot(2,2,3)
+    plot_fp(newBox, boundary, rType, entranceBox);
+    title('Align with neighbors');
+end
+
+% 3. regularize fp, include crop using boundary, gap filling
+[newBox, order] = regularize_fp(newBox, boundary, rType);
+
+% 4. generate the room polygons
+[newBox, rBoundary] = get_room_boundary(newBox, boundary, order);
+    
+if drawResult
+    subplot(2,2,4)
+    plot_fp(newBox(order,:), boundary, rType(order), entranceBox);
+    title('Regularize fp');
+end
+
+% %% option #2: use optimization to align neighbors, and then align the boundary 
+% % 1. get the constraint from the adjacent rooms， and optimize
+% %[constraint1, ~, ~] = align_with_boundary(rBox, boundary, threshold, rNode);
+% [constraint2, ~, ~] = align_neighbor(rBox, rEdge, [], threshold+2);
+% newBox = optimize_fp(rBox, [], constraint2);
+% if drawResult
+%     subplot(3,4,6)
+%     plot_fp(newBox, boundary, rNode, entranceBox);
+%     title('Optimize the neighboring');
+% end
+% 
+% % 2. align with boundary after the neighbors have been aligned
+% [constraint1, newBox2, ~] = align_with_boundary(newBox, boundary, threshold, rNode);
+% if drawResult
+%     subplot(3,4,7)
+%     plot_fp(newBox2, boundary, rNode, entranceBox);
+%     title('Align with boundary w/o optimization');
+% end
+% 
+% % 3. regularize fp, include crop using boundary, gap filling
+% [newBox2, order] = regularize_fp(newBox2, boundary, rNode);
+% if drawResult
+%     subplot(3,4,8)
+%     plot_fp(newBox2(order,:), boundary, rNode(order,:), entranceBox);
+%     title('Regularize fp');
+% end
+% 
+% 
+% 
+% newBox = optimize_fp(newBox, constraint1, constraint2);
+% if drawResult
+%     subplot(3,4,11)
+%     plot_fp(newBox, boundary, rNode, entranceBox);
+%     title('Align with boundary with optimization');
+% end
+% 
+% % 3. regularize fp, include crop using boundary, gap filling
+% [newBox, order] = regularize_fp(newBox, boundary, rNode);
+% if drawResult
+%     subplot(3,4,12)
+%     plot_fp(newBox(order,:), boundary, rNode(order,:), entranceBox);
+%     title('Regularize fp');
+%     if ~isempty(figName)
+%         saveas(gcf, figName);
+%     end
+% end
+% 
+
+
+
+%%
+end
+

align_fp/align_neighbor.m

@@ -0,0 +1,53 @@
+function [constraint, box, updated] = align_neighbor(box, rEdge, updated, threshold)
+
+if isempty(updated)
+    updated = false(size(box));
+end
+
+tempBox = box;
+constraint = zeros(size(rEdge, 1)*3, 2); 
+iBegin = 1;
+checked = false(size(rEdge, 1), 1);
+updatedCount = get_updated_count(updated, rEdge);
+for i = 1:size(rEdge, 1)
+    I = find(~checked);
+    [~, t] = maxk(updatedCount(I), 1);
+    checked(I(t)) = true;
+    idx = rEdge(I(t),1:2)+1;
+    [b, c] = align_adjacent_room3(box(idx, :), tempBox(idx, :), updated(idx,:), rEdge(I(t),3), threshold);
+    for j = 1:length(idx)
+        
+        updated(idx(j), c(:,j)) = true;
+        
+        c(:, j) = (c(:,j)-1)*size(box,1) + double(idx(j)); 
+        
+        if b(j, 1) == b(j, 3)
+            b(j, [1 3]) = box(idx(j), [1 3]);
+            updated(idx(j), c(:,j)) = false;
+        end
+        if b(j, 2) == b(j, 4)
+            b(j, [2 4]) = box(idx(j), [2 4]);
+            updated(idx(j), c(:,j)) = false;
+        end
+        
+    end
+    box(idx, :) = b;
+    
+    
+    cNum = size(c, 1);
+    
+    constraint(iBegin:iBegin+cNum-1, :) = c;
+    iBegin = iBegin+cNum;
+    
+    updatedCount = get_updated_count(updated, rEdge);
+end
+constraint = constraint(1:iBegin-1, :);
+
+function updatedCount = get_updated_count(updated, rEdge)
+    updatedCount = zeros(size(rEdge, 1), 1);
+    for k = 1:size(rEdge, 1)
+        index = rEdge(k,1:2)+1;
+        updatedCount(k) = sum(sum(updated(index,:)));
+    end
+end
+end

align_fp/align_with_boundary.m

@@ -0,0 +1,29 @@
+function [constraint, box, updated] = align_with_boundary(box, boundary, threshold, rType)
+tempBox = box;
+updated = false(size(box));
+closedSeg = zeros(size(box));
+distSeg = zeros(size(box));
+for i = 1:length(box)
+    [closedSeg(i,:), distSeg(i,:)] = find_close_seg(box(i,:), boundary); 
+end
+
+
+box(distSeg <= threshold) = closedSeg(distSeg <= threshold);
+updated(distSeg <= threshold) = true;
+idx = find(distSeg <= threshold);
+constraint = [idx closedSeg(idx)];
+
+
+% check if any room box blocks the door
+entranceBox = get_entrance_space(boundary(1:2, 1:2), boundary(1,3), threshold);
+entrancePoly = polyshape(entranceBox([1 1 3 3]), entranceBox([2 4 4 2]));
+for i = 1:length(box)
+    if rType(i) ~= 10 && rType(i) ~= 0
+        roomPoly = polyshape(box(i, [1 1 3 3]), box(i, [2 4 4 2]));
+        if overlaps(entrancePoly, roomPoly)
+            box(i,:) = shrink_box(roomPoly, entrancePoly, boundary(1,3));
+            updated(i, box(i,:)==tempBox(i,:)) = false;
+            updated(i, box(i,:)~=tempBox(i,:)) = true;
+        end
+    end        
+end

align_fp/find_close_seg.m

@@ -0,0 +1,74 @@
+function [closedSeg, distSeg, idx] = find_close_seg(box, boundary)
+
+% need to carefully select the closed wall seg for each box
+% cannot introduce a hole inside the boundary
+
+isNew = boundary(:,4);
+boundary = double(boundary(~isNew, :));
+
+% get the ordered horizontal and vertical segments on the boundary
+bSeg = [boundary(:, 1:2), boundary([2:end 1], 1:2), boundary(:,3)];
+vSeg = bSeg(mod(boundary(:,3), 2)==1, :);
+vSeg(vSeg(:,5)==3, [2 4]) = vSeg(vSeg(:,5)==3, [4 2]);
+[~, I] = sort(vSeg(:,1));
+vSeg = vSeg(I,:);
+
+hSeg = bSeg(mod(boundary(:,3), 2)==0, :);
+hSeg(hSeg(:,5)==2, [1 3]) = hSeg(hSeg(:,5)==2, [3 1]);
+[~, I] = sort(hSeg(:,2));
+hSeg = hSeg(I,:);
+
+closedSeg = ones(1,4)*256;
+distSeg = ones(1,4)*256;
+idx = zeros(1, 4);
+
+% check vertial seg
+for i = 1:size(vSeg,1)
+    seg = vSeg(i, :);
+    vdist = 0;
+    if seg(4) <= box(2) 
+        vdist = box(2) - seg(4);
+    elseif seg(2) >= box(4) 
+        vdist = seg(2) - box(4);
+    end
+    
+    hdist = box([1 3]) - seg(1);
+    dist1 = norm(double([hdist(1), vdist])); 
+    dist3 = norm(double([hdist(2), vdist])); 
+    
+    if dist1 < distSeg(1) && dist1 <= dist3 &&  hdist(1) > 0 
+        distSeg(1) = dist1;
+        idx(1) = i;
+        closedSeg(1) = seg(1);
+    elseif dist3 < distSeg(3) && hdist(2) < 0 
+        distSeg(3) = dist3;
+        idx(3) = i;
+        closedSeg(3) = seg(3);
+    end
+end
+
+% check horizontal seg
+for i = 1:size(hSeg,1)
+    
+    seg = hSeg(i, :);
+    hdist = 0;
+    if seg(3) <= box(1) 
+        hdist = box(1) - seg(3);
+    elseif seg(1) >= box(3) 
+        hdist = seg(1) - box(3);
+    end
+    
+    vdist = box([2 4]) - seg(2);
+    dist2 = norm(double([vdist(1), hdist]));
+    dist4 = norm(double([vdist(2), hdist]));
+    
+    if dist2 <= dist4 && dist2 < distSeg(2) &&  vdist(1) > 0 
+        distSeg(2) = dist2;
+        idx(2) = i;
+        closedSeg(2) = seg(2);
+    elseif dist4 < distSeg(4) && vdist(2) < 0 
+        distSeg(4) = dist4;
+        idx(4) = i;
+        closedSeg(4) = seg(4);
+    end
+end

align_fp/find_room_order.m

@@ -0,0 +1,29 @@
+function order = find_room_order(M)
+
+n = size(M,1);
+G = digraph(M);
+name = cell(n,1);
+for i = 1:n
+    name{i} = num2str(i);
+end
+G.Nodes.Name = name;
+
+order = zeros(n, 1);
+i = 1;
+while i <= n
+    D = indegree(G);
+    c = find(D==0);
+    if isempty(c)
+        idx = find(D==1);
+        c = setdiff(idx, order);
+        order(i) = str2double(G.Nodes.Name{c(1)});
+        G = rmnode(G, c(1));
+        i = i+1;
+    else
+        for j = 1:length(c)
+            order(i+j-1) = str2double(G.Nodes.Name{c(j)});
+        end
+        G = rmnode(G, c);
+        i = i + length(c);
+    end
+end

align_fp/get_entrance_space.m

@@ -0,0 +1,14 @@
+
+function doorBox = get_entrance_space(doorSeg, doorOri, threshold)
+
+doorBox = [doorSeg(1,:) doorSeg(2,:)];
+if doorOri == 0
+    doorBox(4) = doorBox(4) + threshold;
+elseif doorOri == 1
+    doorBox(1) = doorBox(1) - threshold;
+elseif doorOri == 2
+    doorBox(2) = doorBox(2) - threshold;
+elseif doorOri == 3
+    doorBox(3) = doorBox(3) + threshold;
+end
+    

align_fp/get_room_boundary.m

@@ -0,0 +1,25 @@
+function [newBox, rBoundary] = get_room_boundary(box, boundary, order)
+
+isNew = boundary(:,4);
+polyBoundary = polyshape(boundary(~isNew,1),  boundary(~isNew,2));
+
+poly = cell(size(box,1), 1);
+for i = 1:size(box,1)
+    poly{i} = polyshape(box(i, [1 1 3 3]), box(i, [2 4 4 2]));
+end
+
+newBox = box;
+rBoundary = cell(size(box,1), 1);
+for i = 1:size(box,1)
+    idx = order(i);
+    
+    rPoly = intersect(polyBoundary, poly{idx}); 
+    for j = i+1:size(box,1)
+        rPoly = subtract(rPoly, poly{order(j)});
+    end
+    rBoundary{idx} = rPoly.Vertices;
+    [xLimit, yLimit]= boundingbox(rPoly);
+    if ~isempty(xLimit)
+        newBox(idx,:) = [xLimit(1) yLimit(1) xLimit(2), yLimit(2)];
+    end
+end

align_fp/regularize_fp.m

@@ -0,0 +1,111 @@
+function [box, order] = regularize_fp(box, boundary, rType)
+
+% 1. use the boundary to crop each room box
+isNew = boundary(:,4);
+polyBoundary = polyshape(boundary(~isNew,1),  boundary(~isNew,2));
+for i = 1:size(box, 1)
+    polyRoom = polyshape(box(i, [1 1 3 3]), box(i, [2 4 4 2]));
+    [xLimit, yLimit] = boundingbox(intersect(polyBoundary,polyRoom));
+    if isempty(xLimit)
+        disp('One room outside the building!'); 
+    else
+        box(i,:) = [xLimit(1) yLimit(1) xLimit(2), yLimit(2)];
+    end
+end
+
+
+% 2. check if there is any overlapped region to determine the layer of boxes
+orderM = false(size(box,1), size(box,1));
+for i = 1:size(box,1)
+    polyRoom1 = polyshape(box(i, [1 1 3 3]), box(i, [2 4 4 2]));
+    area1 = area(polyRoom1);
+    for j = i+1:size(box,1)
+         polyRoom2 = polyshape(box(j, [1 1 3 3]), box(j, [2 4 4 2]));
+         area2 = area(polyRoom2);
+         inter = intersect(polyRoom1, polyRoom2);
+         if inter.NumRegions >= 1
+             if area1 <= area2 % may need to add the FP into consideration
+                 orderM(i,j) = true;
+             else
+                 orderM(j,i) = true;
+             end
+         end
+    end
+end
+order = 1:size(box,1);
+if any(orderM(:))
+    order = find_room_order(orderM);
+end
+order = order(end:-1:1);
+
+% 3. check if there are more than one uncovered regions inside the building
+livingIdx = find(rType==0);
+for i = 1:size(box, 1)
+    if i ~= livingIdx
+       if box(i,1)==box(i,3) || box(i,2)==box(i,4)
+           disp('Empty box!!!');
+       else
+           polyRoom = polyshape(box(i, [1 1 3 3]), box(i, [2 4 4 2]));
+           polyBoundary = subtract(polyBoundary,polyRoom);
+       end
+       
+    end
+end
+livingPoly = polyshape(box(livingIdx, [1 1 3 3]), box(livingIdx, [2 4 4 2]));
+
+gap = polyBoundary;
+if gap.NumRegions == 1
+    [xLimit, yLimit] = boundingbox(gap);
+    box(livingIdx,:) = [xLimit(1) yLimit(1) xLimit(2), yLimit(2)];
+else
+    rIdx = find(isnan(gap.Vertices(:,1)));
+    rIdx = [rIdx; size(gap.Vertices,1)+1];
+    
+    % for each region, check if it intersects with the living room, 
+    % otherwise get the room label and find the room that should cover 
+    % the region
+    
+    region = cell(length(rIdx), 1);
+    overlapArea = zeros(length(rIdx), 1);
+    closeRoomIdx = zeros(length(rIdx), 1);
+    idx = 1;
+    for k = 1:length(rIdx)
+        regionV = gap.Vertices(idx:rIdx(k)-1, :);
+        idx = rIdx(k) + 1;
+        region{k} = polyshape(regionV);
+        
+        if overlaps(region{k}, livingPoly)
+            iter = intersect(region{k}, livingPoly);
+            overlapArea(k) = area(iter);
+        end
+        
+        [x, y] = centroid(region{k});
+        center = [x, y];
+        
+        dist = 256;
+        bIdx = 0;
+        for i = 1:size(box, 1)
+            b = box(i, :);
+            bCenter = double([(b(:,1)+b(:,3))/2, (b(:,2)+b(:,4))/2]);
+            d = norm(bCenter-center);
+            if d<dist
+                dist = d;
+                bIdx = i;
+            end
+        end
+        closeRoomIdx(k) = bIdx;
+    end 
+    
+    [~, lIdx] = max(overlapArea);
+    for k = 1:length(closeRoomIdx)
+        if k == lIdx
+            [xLimit, yLimit] = boundingbox(region{k});
+            box(livingIdx,:) = [xLimit(1) yLimit(1) xLimit(2), yLimit(2)];
+        else
+            room = polyshape(box(closeRoomIdx(k), [1 1 3 3]), box(closeRoomIdx(k), [2 4 4 2]));
+            [xLimit, yLimit] = boundingbox(union(room, region{k}));
+            box(closeRoomIdx(k),:) = [xLimit(1) yLimit(1) xLimit(2), yLimit(2)];
+        end
+    end        
+end
+    

align_fp/shrink_box.m

@@ -0,0 +1,61 @@
+function box = shrink_box(roomPoly, entrancePoly, doorOrient)
+
+[PG, shapeId, ~] = subtract(roomPoly, entrancePoly);
+idx1 = find(shapeId==1);
+d = idx1(2:end) - idx1(1:end-1);
+i = find(d~=1);
+if ~isempty(i)
+    idx1 = idx1([i+1:end 1:i]);
+end
+
+idx2 = find(shapeId~=1);
+d = idx2(2:end) - idx2(1:end-1);
+i = find(d~=1);
+if ~isempty(i)
+    idx2 = idx2([i+1:end 1:i]);
+end
+
+remainPoint = length(idx1);
+if remainPoint == 2
+    box = [min(PG.Vertices) max(PG.Vertices)];
+elseif remainPoint == 3
+    assert(length(idx2) == 3);
+    pointSet1 = PG.Vertices([idx1(1:2); idx2(2)], :);
+    pointSet2 = PG.Vertices([idx1(2:3); idx2(2)], :);
+    if mod(doorOrient, 2) == 0 % door grow vertically
+        if pointSet1(1,1) ==  pointSet1(2,1)
+            box = [min(pointSet1) max(pointSet1)];
+        else
+            box = [min(pointSet2) max(pointSet2)];
+        end
+    else
+        if pointSet1(1,2) ==  pointSet1(2,2)
+            box = [min(pointSet1) max(pointSet1)];
+        else
+            box = [min(pointSet2) max(pointSet2)];
+        end
+    end
+elseif remainPoint == 4 
+    % elseif remainPoint == 4 && length(idx2) == 4
+%     pointSet = PG.Vertices([idx1(2:3); idx2(2:3)], :);
+%     box = [min(pointSet) max(pointSet)];
+% elseif remainPoint == 4 % door inside the box
+    [x1, y1] = centroid(roomPoly);
+    [x2, y2] = centroid(entrancePoly);
+    box = [min(roomPoly.Vertices)  max(roomPoly.Vertices)];
+    if mod(doorOrient, 2) == 0 % door grow vertically
+        if x1 < x2
+            box(3) = min(entrancePoly.Vertices(:,1));
+        else
+            box(1) = max(entrancePoly.Vertices(:,1));
+        end
+    else
+        if y1 < y2
+            box(4) = min(entrancePoly.Vertices(:,2));
+        else
+            box(2) = max(entrancePoly.Vertices(:,2));
+        end
+    end
+else
+    disp(['There are other cases with point number = ', num2str(length(shapeId))]);
+end

manage.py

@@ -0,0 +1,21 @@
+#!/usr/bin/env python
+"""Django's command-line utility for administrative tasks."""
+import os
+import sys
+
+
+def main():
+    os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'House.settings')
+    try:
+        from django.core.management import execute_from_command_line
+    except ImportError as exc:
+        raise ImportError(
+            "Couldn't import Django. Are you sure it's installed and "
+            "available on your PYTHONPATH environment variable? Did you "
+            "forget to activate a virtual environment?"
+        ) from exc
+    execute_from_command_line(sys.argv)
+
+
+if __name__ == '__main__':
+    main()