test

DataPreparation/1.tf_train.py

@@ -0,0 +1,102 @@
+import os
+import pickle
+import numpy as np
+import scipy.io as sio
+from config import data_path
+from tqdm.auto import tqdm
+
+def compute_tf(boundary):
+    '''
+    input: boundary points array (x,y,dir,isNew)
+    return: tf.x, tf.y
+    '''
+    if boundary.shape[1]>2:
+        boundary=boundary[:,:2]
+    boundary = np.concatenate((boundary,boundary[:1]))
+    num_point = len(boundary)-1
+    line_vector = boundary[1:]-boundary[:-1]
+    line_length = np.linalg.norm(line_vector,axis=1)
+    
+    perimeter = line_length.sum()
+    line_vector = line_vector/perimeter
+    line_length = line_length/perimeter
+
+    angles = np.zeros(num_point)
+    for i in range(num_point):
+        z = np.cross(line_vector[i],line_vector[(i+1)%num_point])
+        sign = np.sign(z)
+        angles[i] = np.arccos(np.dot(line_vector[i],line_vector[(i+1)%num_point]))*sign
+
+    x = np.zeros(num_point+1)
+    y = np.zeros(num_point+1)
+    s = 0
+    for i in range(1,num_point+1):
+        x[i] = line_length[i-1]+x[i-1]
+        y[i-1] = angles[i-1]+s
+        s = y[i-1]
+    y[-1] = s
+    return x,y
+
+def compute_tf_dist(tf1,tf2):
+    x = np.unique(np.concatenate((tf1['x'],tf2['x'])))
+    dist = 0
+    idx1,idx2 =0,0
+    for i in range(1,len(x)-1):
+        idx1 = idx1+(x[i]>tf1['x'][idx1+1])
+        idx2 = idx2+(x[i]>tf2['x'][idx2+1])
+        seg = x[i]-x[i-1]
+        d = abs(tf1['y'][idx1]-tf2['y'][idx2])
+        dist = dist+seg*d
+    seg = x[-1]-x[-2]
+    d = abs(tf1['y'][-1]-tf2['y'][-1])
+    dist = dist+seg*d
+    return dist
+
+def sample_tf(x,y,ndim=1000):
+    '''
+    input: tf.x,tf.y, ndim
+    return: n-dim tf values
+    '''
+    t = np.linspace(0,1,ndim)
+    return np.piecewise(t,[t>=xx for xx in x],y)
+
+# load data
+data = sio.loadmat(data_path, squeeze_me=True, struct_as_record=False)['data']
+data_dict = {d.name:d for d in data}
+
+names_train = open('./data/train.txt').read().split('\n')
+names_test = open('./data/test.txt').read().split('\n')
+n_train = len(names_train)
+n_test = len(names_test)
+
+# turning function: training data
+trainTF = []
+tf_train = []
+for i in tqdm(range(n_train)):
+    boundary = data_dict[names_train[i]].boundary
+    x,y = compute_tf(boundary)
+    trainTF.append({'x':x,'y':y})
+pickle.dump(trainTF,open('./data/trainTF.pkl','wb'))
+
+tf_train = []
+for i in tqdm(range(n_train)):
+    x,y = trainTF[i]['x'],trainTF[i]['y']
+    tf_train.append(sample_tf(x,y))
+tf_train = np.stack(tf_train,axis=0)
+np.save('./data/tf_train.npy',tf_train)
+      
+# turning function: testing data                   
+testTF = []
+for i in tqdm(range(n_test)):
+    boundary = data_dict[names_test[i]].boundary
+    x,y = compute_tf(boundary)
+    testTF.append({'x':x,'y':y})
+pickle.dump(testTF,open('./data/testTF.pkl','wb'))
+
+# turning function distance: test-train
+print('Computing turning function distance ... it will take a long time.')
+D_test_train = np.zeros((n_test,n_train),dtype='float32')
+for i in tqdm(range(n_test)):
+    for j in range(n_train):
+        D_test_train[i,j] = compute_tf_dist(testTF[i],trainTF[j])
+np.save('./data/D_test_train.npy',D_test_train)

DataPreparation/2.data_train_converted.py

@@ -0,0 +1,32 @@
+import numpy as np
+import pickle
+import scipy.io as sio
+from config import data_path
+from tqdm.auto import tqdm
+
+# load data
+data = sio.loadmat(data_path, squeeze_me=True, struct_as_record=False)['data']
+data_dict = {d.name:d for d in data}
+
+names_train = open('./data/train.txt').read().split('\n')
+n_train = len(names_train)
+
+trainTF = pickle.load(open('./data/trainTF.pkl','rb'))
+
+data_converted = []
+
+for i in tqdm(range(n_train)):
+    d = data_dict[names_train[i]]
+    d_converted = {}
+    d_converted['name'] = d.name
+    d_converted['boundary'] = d.boundary
+    d_converted['box'] = np.concatenate([d.gtBoxNew,d.rType[:,None]],axis=-1)
+    d_converted['order'] = d.order
+    d_converted['edge'] = d.rEdge
+    d_converted['rBoundary'] = d.rBoundary
+    data_converted.append(d_converted)
+
+sio.savemat('./data/data_train_converted.mat',{'data':data_converted,'nameList':names_train,'trainTF':trainTF})
+data = sio.loadmat('./data/data_train_converted.mat', squeeze_me=True, struct_as_record=False)
+pickle.dump(data,open('./data/data_train_converted.pkl','wb'))
+

DataPreparation/3.rNum_train.py

@@ -0,0 +1,20 @@
+
+import numpy as np
+import scipy.io as sio
+from config import data_path
+from tqdm.auto import tqdm
+
+data = sio.loadmat(data_path, squeeze_me=True, struct_as_record=False)['data']
+data_dict = {d.name:d for d in data}
+
+names_train = open('./data/train.txt').read().split('\n')
+n_train = len(names_train)
+
+rNum = np.zeros((n_train,14),dtype='uint8')
+for i in tqdm(range(n_train)):
+    rType = data_dict[names_train[i]].rType
+    for j in range(13):
+        rNum[i,j] = (rType==j).sum()
+    rNum[i,13] = rNum[i,[1,5,6,7,8]].sum()
+
+np.save('./data/rNum_train.npy',rNum)

DataPreparation/4.data_train_eNum.py

@@ -0,0 +1,32 @@
+from os import rmdir
+import numpy as np
+import pickle
+import scipy.io as sio
+from tqdm.auto import tqdm
+
+data = pickle.load(open('./data/data_train_converted.pkl','rb'))['data']
+names_train = open('./data/train.txt').read().split('\n')
+n_train = len(names_train)
+
+eNum = np.zeros((n_train,25),dtype='uint8')
+for i in tqdm(range(n_train)):
+    d = data[i]
+    rType = d.box[:,-1]
+    eType = rType[d.edge[:,:2]]
+    # classfication
+    rMap = np.array([1,2,3,4,1,2,2,2,2,5,1,6,1,10,7,8,9,10])-1 # matlab to python
+    edge = rMap[eType]
+    reorder = np.array([0,1,3,2,4,5])
+    edge = reorder[edge]
+    I = (edge[:,0]<=5)&(edge[:,0]>=1)&(edge[:,1]<=5)&(edge[:,1]>=1)
+    edge = edge[I,:]-1 # matlab to python
+    e = np.zeros((5,5),dtype='uint8') 
+    for j in range(len(edge)):
+        e[edge[j,0],edge[j,1]] = e[edge[j,0],edge[j,1]]+1
+        if edge[j,0] != edge[j,1]:
+            e[edge[j,1],edge[j,0]] = e[edge[j,1],edge[j,0]]+1
+    
+    eNum[i] = e.reshape(-1)
+
+pickle.dump({'eNum':eNum},open('./data/data_train_eNum.pkl','wb'))
+

DataPreparation/5.data_test_converted.py

@@ -0,0 +1,31 @@
+import numpy as np
+import pickle
+import scipy.io as sio
+from config import data_path
+from tqdm.auto import tqdm
+
+data = sio.loadmat(data_path, squeeze_me=True, struct_as_record=False)['data']
+data_dict = {d.name:d for d in data}
+testTF = pickle.load(open('./data/testTF.pkl','rb'))
+rNum = np.load('./data/rNum_train.npy')
+
+names_train = open('./data/train.txt').read().split('\n')
+names_test = open('./data/test.txt').read().split('\n')
+n_train = len(names_train)
+n_test = len(names_test)
+
+D = np.load('./data/D_test_train.npy')
+data_converted = []
+for i in tqdm(range(n_test)):
+    d = data_dict[names_test[i]]
+    d_converted = {}
+    d_converted['boundary'] = d.boundary
+    d_converted['tf'] = testTF[i]
+    topK = np.argsort(D[i])[:1000]
+    d_converted['topK'] = topK
+    d_converted['topK_rNum'] = rNum[topK]
+    data_converted.append(d_converted)
+
+sio.savemat('./data/data_test_converted.mat',{'data':data_converted,'testNameList':names_test,'trainNameList':names_train})
+data = sio.loadmat('./data/data_test_converted.mat', squeeze_me=True, struct_as_record=False)
+pickle.dump(data,open('./data/data_test_converted.pkl','wb'))

DataPreparation/6.cluster.py

@@ -0,0 +1,38 @@
+import pickle
+import numpy as np
+import faiss
+from tqdm.auto import tqdm
+
+def sample_tf(x,y,ndim=1000):
+    '''
+    input: tf.x,tf.y, ndim
+    return: n-dim tf values
+    '''
+    t = np.linspace(0,1,ndim)
+    return np.piecewise(t,[t>=xx for xx in x],y)
+
+tf_train = pickle.load(open('./data/trainTF.pkl','rb'))
+
+tf = []
+for i in tqdm(range(len(tf_train))):
+    tf_i = tf_train[i]
+    tf.append(sample_tf(tf_i['x'],tf_i['y']))
+
+d = 1000
+tf = np.array(tf).astype(np.float32)
+
+ncentroids = 1000
+niter = 200
+verbose = True
+
+kmeans = faiss.Kmeans(d, ncentroids, niter=niter, verbose=verbose,gpu=True)
+kmeans.train(tf)
+centroids = kmeans.centroids
+
+index = faiss.IndexFlatL2(d)
+index.add(tf)
+nNN = 1000
+D, I = index.search (kmeans.centroids, nNN)
+
+np.save(f'./data/centroids_train.npy',centroids)
+np.save(f'./data/clusters_train.npy',I)

DataPreparation/README.md

@@ -0,0 +1,89 @@
+**1. Data from RPLAN to Graph2Plan**
+
+Please refer to https://github.com/zzilch/RPLAN-Toolbox.
+You can also download the extracted data from [here](http://vcc.tech/file/upload_file/Data/G2P/Data.7z).
+You can load the `Network/data/data.mat` in Matlab to chek the data structure.
+
+![data.mat](../Interface/Img/data.mat.png)
+
+Data fields:
+
+- name: file name in RPLAN
+- boundary: (x,y,dir,isNew)
+    - first two point indicate the front door.
+    - dir: 0(right)/1(down)/2(left)/3(up) for `dir`. 
+    - `isNew` means the point is not a corner point (usually a point of door)
+- order: room order, the larger one will cover the smaller one.
+- rType: room categories
+```
+# index,name,type(private/public),floorTexture
+room_label = [
+    (0, 'LivingRoom', 1, "PublicArea"),
+    (1, 'MasterRoom', 0, "Bedroom"),
+    (2, 'Kitchen', 1, "FunctionArea"),
+    (3, 'Bathroom', 0, "FunctionArea"),
+    (4, 'DiningRoom', 1, "FunctionArea"),
+    (5, 'ChildRoom', 0, "Bedroom"),
+    (6, 'StudyRoom', 0, "Bedroom"),
+    (7, 'SecondRoom', 0, "Bedroom"),
+    (8, 'GuestRoom', 0, "Bedroom"),
+    (9, 'Balcony', 1, "PublicArea"),
+    (10, 'Entrance', 1, "PublicArea"),
+    (11, 'Storage', 0, "PublicArea"),
+    (12, 'Wall-in', 0, "PublicArea"),
+    (13, 'External', 0, "External"),
+    (14, 'ExteriorWall', 0, "ExteriorWall"),
+    (15, 'FrontDoor', 0, "FrontDoor"),
+    (16, 'InteriorWall', 0, "InteriorWall"),
+    (17, 'InteriorDoor', 0, "InteriorDoor")
+]
+```
+- rBoundary: (x,y), boundary points for each room
+- gtBox: (y0,x0,y1,x1), min-max bounds of a room [RPLAN]
+- gtBoxNew: (x0,y0,x1,y1), min-max bounds of a room [Graph2Plan]
+- rEdge: (u,v,r), room indices and relative position(u relative to v)
+```
+edge_type = [
+    'left-above',
+    'left-below',
+    'left-of',
+    'above',
+    'inside',
+    'surrounding',
+    'below',
+    'right-of',
+    'right-above',
+    'right-below'
+]
+```
+
+**2. Data from Network to GUI**
+
+We provide scripts to create the same data as we provided in Interface. Like DeepLayout, we use 75k for training and about 3k for validation and test.
+Started from the `Network/data/data.mat`:
+
+0. Change the data path to the `data.mat` in `config.py`
+1. Run `1.tf_train.py`. It will create:
+    - `trainTF.pkl`, `testTF.pkl`: Piecewise turning function. Each element is a dict like `{'x':[x0,...,xn],'y':[y0,...,yn]}`
+    - `tf_train.npy`: Sampled turning function with shape (ntrain,1000)
+    - `D_test_train.npy`: Truning function distance matrix with shape (ntest,ntrain)
+2. Run `2.data_train_converted.py`. It will create:
+    - `data_train_converted.mat` & `data_train_converted.pkl`: The `.pkl` one Just a copy of the `.mat` re-dumped with pickle. The data have similar structure with `data.mat`. 
+    - box:(x0,y0,x1,y1,room type)
+    ![data_train_converted.mat](../Interface/Img/data_train_converted.png)
+3. Run `3.rNum_train.py`. It wil create:
+    - `rNum_train.npy`: counts of different room type 
+4. Run `4.data_train_eNum.py`. It will create:
+    - `data_train_eNum.pkl`: A dict like {'eNum':Array with shape (ntrain,25)}. Each array is reshape from (5,5) which means adjacency matrix of 5 coarse room types.
+5. Run `5.data_test_converted.py`. It will create:
+    - `data_train_converted.mat` & `data_train_converted.pkl`: The `.pkl` one Just a copy of the `.mat` re-dumped with pickle. 
+    ![data_test_converted.mat](../Interface/Img/data_test_converted.png)
+
+    Data fileds:
+        - boundary: (x,y,dir,isNew)
+        - tf: Piece with turning function
+        - topK: 1000 indices of the training data has the minimun turning function with current data.
+        - topK_rNum: Counts for differnt room type of each topK room
+6. **[Depends on [faiss](https://github.com/facebookresearch/faiss)]** Run `6.cluster.py`.  It will create:
+    - `centroids_train.npy`: 1000 discrete turning function cluster centroids (1000-d) of training data
+    - `clusters_train.npy`: 1000 nearest neighbors in training data of each centroid

DataPreparation/config.py

@@ -0,0 +1 @@
+data_path = '../Network/data/data.mat'

DataPreparation/data/test.txt

@@ -0,0 +1,2880 @@
+80598
+59984
+33887
+34092
+79214
+57405
+15948
+80054
+45590
+38931
+3669
+37724
+65752
+60276
+2984
+80569
+76155
+48753
+24276
+7584
+28372
+73777
+57560
+17292
+9556
+38997
+33494
+22100
+79282
+39495
+80341
+55518
+47396
+41018
+62007
+34201
+35453
+55224
+75548
+78900
+78527
+56693
+34171
+68576
+71577
+49542
+49298
+12505
+22946
+6305
+51086
+49015
+30845
+5626
+50299
+41353
+64436
+24657
+33774
+40192
+52774
+58008
+60345
+32836
+21207
+60622
+25366
+68686
+63879
+66309
+27186
+14772
+39276
+38445
+63572
+54413
+41517
+47439
+49481
+67677
+16557
+3972
+79384
+15344
+71566
+30484
+22276
+18170
+12214
+30634
+1169
+26617
+57520
+13603
+75321
+62497
+61479
+20342
+12691
+80533
+35072
+16900
+52093
+4203
+48247
+46298
+26966
+48878
+41244
+11606
+7422
+34819
+48698
+32605
+54429
+30841
+17175
+57498
+71265
+77397
+66111
+57248
+74683
+67980
+24269
+75721
+6255
+6881
+26692
+830
+35975
+13073
+30930
+49242
+49504
+63284
+5561
+5909
+70301
+64523
+27325
+68392
+29598
+50565
+68276
+18426
+36358
+40864
+40299
+33935
+77847
+7544
+43055
+15604
+79141
+47835
+2285
+29808
+78202
+53409
+49549
+62338
+62567
+65617
+73079
+38544
+53300
+53474
+2337
+64310
+23235
+58666
+21690
+9406
+69293
+44389
+23712
+9168
+20520
+20352
+12926
+23824
+73793
+71245
+64342
+17839
+24717
+64830
+49892
+41414
+34852
+32725
+58188
+44522
+39018
+53937
+65620
+50588
+19259
+78801
+5267
+55251
+48891
+23839
+34280
+68738
+44892
+8355
+6251
+72376
+17560
+37714
+13909
+50557
+9246
+71545
+69274
+22858
+36625
+22941
+67482
+3760
+56803
+24250
+64949
+21840
+30745
+18820
+23490
+10218
+35561
+70554
+40239
+61987
+77036
+15162
+69028
+66232
+5998
+53577
+30367
+47454
+29119
+80124
+5582
+16648
+30445
+7906
+50127
+5660
+50223
+72333
+59028
+46164
+19457
+77489
+14598
+6433
+68370
+30789
+45897
+41351
+78535
+38055
+66021
+72715
+38562
+11963
+75839
+52223
+38810
+5358
+31218
+35302
+64189
+53439
+1115
+163
+61794
+37405
+11632
+6441
+65615
+19293
+55060
+33271
+33556
+45702
+11023
+66923
+33573
+70743
+65659
+8341
+49116
+51665
+20259
+59378
+50527
+5992
+30502
+69594
+33040
+49649
+75870
+57291
+32302
+4372
+41491
+77111
+60146
+49993
+66860
+6817
+14616
+38606
+14665
+11487
+61656
+29586
+59307
+45089
+67118
+59983
+9721
+33997
+11518
+32280
+59135
+63796
+3275
+37634
+45981
+79769
+36119
+76489
+59018
+37034
+20491
+72217
+69437
+10429
+28838
+52026
+27673
+61812
+35446
+58820
+62099
+45289
+57930
+9759
+45183
+78404
+878
+3856
+55999
+21825
+16182
+68493
+77191
+34223
+35392
+55620
+29855
+8512
+1346
+52068
+4134
+2739
+48916
+64775
+58394
+60278
+41202
+75471
+45720
+30572
+1494
+13919
+48989
+19207
+22306
+9417
+33423
+47560
+25144
+14479
+57024
+80162
+41525
+53246
+20954
+24279
+54286
+1502
+12985
+65391
+52886
+71262
+72534
+41808
+50148
+21602
+29016
+67047
+1034
+12256
+15687
+4497
+11450
+47155
+69200
+25673
+68055
+31828
+65934
+5193
+58654
+42289
+55359
+64182
+73451
+30416
+52349
+28525
+65400
+44292
+41921
+47755
+68816
+76014
+80733
+2612
+50896
+20589
+72793
+41927
+30463
+47569
+44076
+23135
+35861
+50332
+55691
+18364
+19063
+53781
+45225
+79878
+45020
+59208
+69337
+32962
+31743
+46751
+7764
+19664
+58182
+56044
+68770
+19711
+4053
+69209
+75125
+46258
+12654
+55570
+78223
+77751
+37660
+69983
+78155
+74020
+54515
+77551
+43578
+26826
+1425
+60406
+80256
+863
+13759
+28110
+52189
+55360
+43847
+65798
+13195
+14506
+33443
+18803
+70805
+10914
+23678
+48815
+77442
+47561
+35260
+31937
+24721
+59719
+72583
+9585
+68052
+24005
+31470
+27294
+23845
+738
+29272
+62482
+43433
+69714
+74483
+55871
+75053
+50282
+72951
+4422
+75029
+76419
+7467
+58524
+9019
+32868
+65883
+58730
+35459
+29843
+21077
+5438
+35984
+35905
+59783
+324
+29875
+13272
+2849
+55532
+25431
+61610
+71035
+62758
+36166
+57357
+75678
+45754
+44324
+11456
+67397
+29762
+6508
+2914
+46273
+8067
+61508
+65184
+58772
+39974
+47970
+50890
+48349
+65357
+30438
+65795
+1310
+29513
+6379
+18008
+53109
+67666
+42815
+11467
+31982
+75308
+48953
+39067
+26443
+33497
+1650
+29856
+39772
+66906
+65279
+59616
+63165
+25039
+71796
+11494
+19245
+72677
+64502
+32108
+24895
+48758
+5954
+66176
+5550
+23814
+75440
+784
+45211
+4809
+1638
+53375
+42762
+73928
+48896
+46987
+74264
+19751
+22164
+51157
+42736
+73388
+47288
+43873
+46106
+29860
+65459
+40576
+61246
+75348
+57271
+9034
+68182
+75993
+66741
+11375
+54912
+7321
+7094
+52840
+71588
+33375
+75043
+48443
+72086
+30694
+31552
+69725
+62106
+63614
+80276
+78653
+57539
+16380
+24696
+67190
+9807
+6690
+61265
+46309
+33315
+74008
+75396
+23084
+45458
+72553
+68690
+60394
+28109
+15003
+53856
+59173
+60595
+33896
+21694
+48206
+9217
+5041
+7332
+12508
+31204
+72388
+2797
+58172
+27745
+61383
+48978
+33960
+31699
+12656
+59762
+13138
+66203
+62221
+61122
+79726
+1224
+14061
+72169
+43111
+76308
+64863
+44103
+57358
+44787
+38411
+27488
+1243
+5213
+29206
+36236
+45123
+71731
+55887
+44635
+3892
+64929
+69057
+46874
+46466
+15812
+74242
+78386
+29387
+56156
+62630
+23618
+27569
+50625
+42690
+60906
+40196
+29583
+15853
+15689
+50511
+9424
+2381
+40291
+62179
+59889
+37962
+27357
+23920
+16251
+77426
+56950
+8336
+57249
+7832
+38617
+48715
+29967
+70902
+71529
+48289
+79422
+65756
+4784
+32057
+44337
+38161
+6512
+64166
+55057
+43735
+10547
+7833
+78344
+12467
+15534
+19023
+55437
+76749
+4214
+74597
+1693
+33097
+19431
+39422
+74965
+61696
+18635
+71223
+55964
+59112
+4743
+27983
+7727
+56481
+49024
+21612
+61379
+20069
+41614
+32258
+75191
+15606
+6210
+72514
+62763
+46345
+12108
+35204
+38210
+4108
+60901
+30289
+70661
+79968
+51290
+69412
+44363
+13438
+65496
+59423
+41503
+47158
+3242
+52684
+67504
+67277
+3573
+54121
+35282
+51547
+65745
+59918
+76927
+26392
+60246
+24824
+64163
+49114
+79793
+70098
+29724
+71244
+29531
+61464
+53860
+64402
+39481
+74135
+4324
+12340
+6064
+9634
+40168
+49436
+19776
+61612
+71030
+60841
+48589
+16502
+60555
+72662
+57297
+12430
+74871
+22837
+12708
+1107
+68836
+850
+5989
+71058
+7954
+62118
+41682
+59652
+33138
+67656
+54009
+31037
+18486
+4778
+64817
+30705
+73564
+21282
+21109
+22543
+3419
+16521
+27380
+40586
+9501
+26172
+28360
+77674
+68270
+37002
+19914
+38954
+74210
+1212
+74508
+10056
+16622
+42193
+24936
+59102
+30020
+36495
+32713
+76175
+24589
+52705
+60987
+14291
+66618
+76009
+25971
+79773
+18566
+78144
+78351
+57781
+53983
+49080
+10161
+15587
+43457
+62344
+62867
+56561
+70993
+56873
+34953
+61723
+79049
+10232
+3989
+4448
+33365
+22952
+1208
+27400
+41548
+10169
+9603
+20941
+31033
+26705
+48739
+75787
+30073
+42942
+73120
+50075
+75713
+22465
+28234
+9153
+78810
+7552
+28793
+38113
+5094
+46292
+23181
+9010
+9706
+47298
+75343
+77416
+63068
+33225
+38682
+24408
+54974
+15292
+44170
+26770
+33190
+45207
+32708
+24341
+61932
+527
+48802
+48546
+76517
+77129
+67314
+56310
+6521
+51449
+66787
+14210
+315
+70820
+13383
+53566
+67370
+45413
+68172
+50303
+43362
+45147
+59699
+23331
+38713
+78611
+56576
+42342
+3051
+60867
+46805
+3790
+75614
+9592
+31809
+76432
+69968
+40881
+26923
+47225
+70091
+33372
+37465
+56848
+71469
+67890
+267
+5369
+21462
+63336
+49043
+38199
+15956
+74507
+45576
+78778
+3810
+13300
+31046
+3822
+60070
+65442
+57028
+23671
+11906
+48439
+26874
+38195
+56134
+64849
+77289
+70607
+112
+33765
+65926
+15305
+14647
+27398
+61333
+67983
+63422
+9601
+68618
+62852
+58382
+59093
+60125
+22270
+25615
+40806
+59799
+37554
+34554
+1311
+20290
+42058
+70682
+19724
+63248
+73356
+60831
+53231
+32186
+6712
+25485
+80445
+14599
+10370
+23226
+3622
+77862
+40324
+48035
+1458
+29934
+29510
+77540
+62514
+73718
+10489
+77898
+5754
+32570
+60895
+77245
+12570
+49724
+44254
+11894
+77758
+66093
+2022
+8616
+7284
+19665
+33951
+52690
+8066
+7087
+7536
+2436
+40198
+68750
+1021
+29142
+36656
+14129
+69159
+36161
+20114
+68694
+11092
+11398
+25305
+65576
+38663
+22070
+59473
+51257
+64113
+60213
+26280
+26622
+74677
+63958
+60123
+78701
+10868
+21360
+23929
+29607
+11432
+9143
+76214
+56276
+53370
+23910
+29010
+62461
+60848
+46907
+25497
+61934
+35601
+38423
+27189
+61797
+32190
+48332
+18848
+76211
+41438
+71247
+40120
+78470
+36859
+39523
+18079
+720
+32710
+53322
+44380
+2834
+55215
+72529
+39235
+50157
+74745
+6083
+45974
+60407
+34346
+75449
+5715
+5295
+49487
+52205
+78690
+61585
+77574
+27890
+41282
+20966
+61808
+44628
+60823
+13424
+66474
+58152
+32069
+44651
+74004
+24888
+17960
+49880
+19492
+56722
+27437
+20595
+15826
+58811
+35059
+71710
+54563
+7508
+68920
+39890
+4016
+26062
+50575
+67899
+31508
+64008
+28436
+33958
+73990
+25518
+41661
+59613
+21088
+44398
+27174
+13458
+12022
+55226
+70574
+71154
+7620
+77177
+80448
+62623
+66184
+40253
+65133
+66844
+30981
+30604
+73725
+14117
+35900
+69726
+37059
+32035
+37810
+9472
+62609
+57220
+51155
+49692
+11488
+63157
+43002
+6758
+19544
+25967
+28452
+52188
+18481
+27738
+19382
+63751
+38999
+73411
+73638
+74765
+26133
+27699
+56717
+62490
+30343
+13718
+30741
+55286
+594
+68718
+46302
+57656
+23612
+1149
+59908
+1923
+24355
+13515
+12729
+62861
+18694
+51409
+37031
+19504
+26580
+28736
+53170
+48339
+68788
+28489
+37047
+63590
+16509
+77013
+9384
+12628
+44655
+11262
+60499
+75075
+27105
+53057
+52870
+22121
+80589
+65678
+44216
+42936
+54616
+57578
+9311
+53142
+67518
+26398
+26440
+31155
+15896
+79153
+29709
+65117
+66669
+69634
+43460
+20694
+34046
+63457
+17016
+7096
+77383
+39903
+53855
+56861
+53331
+41590
+34752
+8937
+70011
+24498
+43936
+25788
+46649
+58415
+37247
+47380
+14186
+69972
+16768
+40171
+52732
+72560
+8469
+42676
+123
+57128
+62878
+55748
+28246
+78076
+16877
+63883
+45833
+26264
+6327
+51619
+17005
+24502
+19648
+38996
+78078
+26134
+20508
+75249
+79396
+49003
+6860
+77208
+72522
+20244
+49896
+1350
+74493
+49756
+25223
+13434
+76732
+22731
+67205
+66541
+66086
+12373
+32512
+40912
+76337
+77479
+12878
+42902
+51009
+69465
+71025
+12841
+71418
+17906
+47623
+38254
+8072
+14539
+73627
+44602
+69210
+63335
+61342
+48658
+62991
+58349
+55487
+19356
+9409
+7180
+51355
+70919
+49738
+21202
+20437
+33586
+13055
+29708
+49008
+62380
+42036
+68733
+4636
+35318
+24337
+70050
+37507
+42118
+18969
+66796
+27044
+60405
+65061
+73098
+69898
+67302
+3262
+21498
+80367
+29505
+21093
+11952
+34246
+12401
+39347
+8811
+42412
+25693
+49657
+68289
+66208
+44876
+20340
+6757
+36288
+13821
+48355
+8229
+7443
+54914
+54111
+59315
+17240
+69939
+51915
+8885
+27334
+76617
+10791
+64879
+32524
+53243
+43926
+29546
+50657
+50230
+16014
+63354
+59254
+63577
+49111
+75808
+14267
+27063
+28802
+32501
+33943
+68273
+20201
+36960
+71945
+70452
+33447
+55085
+51752
+80461
+55593
+42293
+30935
+25728
+16131
+15360
+66024
+80597
+38066
+42827
+46993
+45910
+25242
+36533
+62138
+37954
+72318
+76262
+23577
+78186
+27054
+18713
+67279
+31403
+6605
+19085
+444
+15012
+26662
+9857
+10423
+40620
+29070
+38341
+40077
+73241
+54714
+2859
+73082
+56695
+51612
+26787
+44639
+8252
+73741
+9535
+41087
+17050
+67577
+56367
+40081
+10531
+38594
+8936
+36144
+21833
+58285
+68034
+78682
+53904
+29928
+40980
+41405
+27671
+67948
+74029
+20374
+26888
+56691
+47880
+66995
+48861
+3566
+43007
+58335
+2057
+78892
+29680
+54081
+13172
+41546
+32230
+32148
+23418
+79416
+30929
+24716
+65440
+67120
+46605
+35998
+23508
+47913
+31124
+8314
+55492
+18249
+4572
+39439
+76017
+41216
+3151
+38757
+63420
+10583
+40893
+18238
+14795
+28151
+80179
+7301
+41584
+5951
+59923
+23686
+9243
+73016
+33390
+70118
+15227
+76552
+19403
+38036
+63235
+47888
+53946
+65830
+35646
+72460
+47800
+63605
+32805
+2133
+77380
+22702
+71902
+36725
+11814
+80245
+50155
+39825
+6099
+69704
+77685
+6148
+72588
+42139
+69653
+38630
+25508
+59262
+50271
+36751
+67139
+27963
+56724
+65208
+45213
+20839
+19989
+74226
+34286
+27992
+67921
+26720
+57670
+56106
+31692
+16101
+62459
+78841
+22235
+27674
+62708
+76622
+343
+1744
+30400
+11038
+21605
+59210
+35438
+26789
+41507
+67353
+28022
+54470
+75778
+47416
+5864
+77876
+32663
+54442
+69149
+67064
+8164
+64199
+2788
+53836
+53207
+65526
+11753
+49517
+14352
+25522
+61544
+3348
+75113
+26765
+63374
+57359
+11884
+41555
+15394
+56136
+64070
+6604
+79680
+75687
+6781
+51680
+42138
+2766
+14809
+77302
+35119
+71084
+65369
+3949
+72607
+69559
+6097
+70006
+989
+8334
+26195
+55193
+77351
+50947
+2108
+48939
+73162
+78465
+31551
+54231
+71947
+27482
+64097
+6166
+23571
+371
+17090
+34227
+36710
+26901
+45599
+61066
+38502
+2768
+54160
+79838
+74811
+34418
+8052
+61521
+45431
+58023
+1945
+75401
+7113
+52153
+29063
+6037
+7453
+45994
+78562
+63939
+65551
+47600
+14193
+42847
+57605
+16397
+40022
+36259
+33769
+41877
+27343
+57850
+9419
+28362
+31296
+65581
+17008
+4289
+77681
+57210
+23511
+3469
+71708
+4831
+22521
+67568
+30121
+55605
+23046
+24015
+7720
+2031
+79078
+22305
+65040
+17635
+35585
+21961
+33553
+40962
+34558
+67519
+42816
+41524
+26429
+13140
+5414
+3839
+45968
+4563
+50509
+9407
+80532
+54994
+16960
+4442
+70395
+38649
+78009
+20512
+51084
+75519
+28668
+76135
+27934
+10306
+19902
+52796
+46488
+72887
+53177
+70157
+38813
+23771
+15097
+44538
+44803
+76054
+60776
+43138
+58635
+64727
+76327
+37824
+78142
+17639
+48114
+47751
+21261
+21053
+20099
+74392
+14396
+9179
+65461
+12184
+13622
+10198
+56537
+63461
+10586
+36440
+76527
+54774
+15500
+8196
+32481
+13580
+17959
+59720
+26589
+29522
+71848
+73535
+70785
+13237
+48924
+18363
+12140
+10981
+17027
+54874
+13081
+59510
+18046
+46071
+51704
+32008
+52236
+54969
+13687
+37588
+64903
+79487
+29559
+3203
+61191
+31402
+30397
+19121
+48501
+68721
+6078
+32076
+6720
+17003
+80355
+59436
+46491
+50367
+38076
+39542
+11289
+47264
+60450
+25986
+30955
+28553
+33757
+45922
+34188
+30138
+43805
+29557
+59987
+20619
+65163
+52207
+828
+48256
+16140
+24444
+34832
+38402
+5191
+70967
+19705
+38085
+13344
+12574
+17402
+77462
+21052
+69169
+11690
+31132
+4058
+14326
+53514
+10703
+34006
+63496
+4789
+60519
+915
+27114
+11272
+28606
+71541
+12023
+31578
+13463
+34131
+33155
+27025
+73747
+75844
+52811
+47360
+79882
+74657
+43875
+76550
+68069
+10251
+62003
+49737
+6428
+32820
+79038
+9645
+30193
+44117
+66384
+51075
+19696
+37308
+42262
+73592
+39037
+54368
+52467
+57814
+25962
+77567
+46808
+19838
+35186
+50655
+40133
+45990
+79259
+33460
+18557
+37365
+61787
+66715
+9471
+27156
+15535
+53350
+34401
+69806
+6473
+27121
+23834
+24687
+19817
+22333
+73139
+11766
+10408
+59220
+4507
+31288
+31778
+20377
+39050
+18521
+9636
+69211
+71416
+22485
+37470
+44917
+62740
+62074
+25840
+62117
+26096
+3096
+75311
+6630
+25597
+35231
+28336
+48182
+28857
+76902
+51337
+44746
+23640
+31762
+46104
+66975
+4275
+58847
+71022
+59939
+46634
+50874
+41959
+21399
+64009
+26767
+48323
+19223
+76075
+20832
+17825
+62681
+25889
+71838
+26569
+36984
+29338
+18824
+73015
+56697
+5059
+16308
+63845
+43672
+64084
+70763
+26122
+14629
+66142
+29043
+29453
+45728
+36470
+50844
+38426
+5004
+49214
+2990
+1608
+52860
+44234
+68386
+13145
+60938
+79089
+38413
+9493
+77780
+18859
+3522
+35451
+62127
+27709
+10440
+70730
+80449
+79387
+5514
+24473
+30451
+76855
+730
+52102
+48199
+18695
+49561
+9043
+18400
+62827
+50292
+62136
+37387
+15731
+820
+34243
+42480
+56701
+78028
+21501
+32476
+22961
+23523
+38287
+62910
+15770
+25742
+59386
+48562
+74441
+77033
+37025
+53041
+75618
+28608
+41543
+44818
+70498
+54741
+31341
+16800
+27695
+59581
+48296
+18348
+11271
+31763
+10417
+67092
+47547
+3752
+7368
+3751
+64648
+56052
+10473
+24804
+31020
+79918
+5458
+31084
+4757
+62298
+36997
+1282
+58739
+36689
+46044
+69099
+57984
+26927
+7221
+2596
+9569
+10435
+72368
+27626
+66551
+24511
+74539
+54130
+47935
+30554
+16378
+74101
+51983
+62779
+44931
+20581
+20110
+58227
+74113
+76269
+30944
+16389
+18028
+69246
+42962
+37727
+26231
+18738
+38702
+71841
+6498
+59610
+34325
+34316
+25148
+50522
+32063
+64387
+40162
+45193
+33237
+31411
+18791
+7621
+543
+59314
+28866
+73751
+32526
+75802
+34438
+77509
+64469
+12059
+75770
+73952
+80268
+4104
+28516
+22829
+12834
+70679
+482
+80703
+79527
+14623
+12790
+12712
+49391
+60696
+274
+23521
+4906
+2462
+52002
+59476
+77362
+24413
+29604
+60288
+77427
+42782
+27877
+40557
+21221
+22427
+36941
+32738
+35359
+61552
+6214
+9941
+70443
+8160
+28302
+55709
+66854
+68563
+71988
+60514
+9782
+44481
+16195
+51651
+54559
+72733
+7996
+60711
+10657
+21535
+38944
+563
+57553
+54227
+40478
+59576
+52672
+60505
+30449
+49829
+52170
+31636
+62083
+41125
+75369
+6585
+75219
+72689
+45972
+50023
+78278
+73608
+24357
+57650
+71087
+56439
+13058
+50187
+35416
+69597
+58584
+66259
+7491
+65360
+75314
+821
+18332
+1711
+23794
+14354
+61257
+16980
+24627
+37079
+54852
+44977
+50079
+69527
+61641
+49762
+66310
+70433
+3353
+70825
+8579
+76251
+44063
+14777
+63385
+65840
+13926
+51683
+28867
+59584
+24007
+67825
+2333
+75009
+26025
+20768
+39768
+67349
+861
+68222
+35865
+46997
+46337
+51607
+15903
+9506
+69980
+64110
+7769
+50912
+38212
+52069
+41820
+38003
+67958
+42897
+31494
+17309
+32461
+36202
+16042
+60928
+26273
+60780
+1381
+58595
+54532
+58552
+57345
+5680
+64941
+61645
+80273
+43461
+12079
+1680
+51251
+80244
+77863
+17236
+24878
+45430
+16830
+67839
+1319
+71663
+12093
+35676
+16539
+53250
+2628
+39089
+35090
+53686
+46459
+17739
+9256
+22366
+54259
+39090
+20666
+25709
+34698
+13232
+6691
+54136
+1413
+79483
+10756
+74962
+79645
+13803
+16293
+45189
+64463
+27257
+45797
+28976
+2568
+11812
+43290
+43334
+62500
+22862
+73662
+60989
+71471
+49924
+12662
+60943
+25229
+21062
+13544
+63619
+2941
+9031
+6737
+19453
+16928
+78431
+28674
+5001
+37639
+36585
+23793
+71163
+75182
+22897
+62553
+28471
+13744
+6996
+26448
+14397
+21105
+15863
+74276
+3193
+23061
+29032
+29925
+397
+36538
+65359
+25197
+71693
+71195
+39006
+30237
+19295
+10210
+5289
+38800
+66970
+45351
+34496
+14567
+56284
+64862
+76287
+52452
+3720
+16709
+51260
+29176
+47673
+27993
+9339
+59514
+25042
+3646
+76958
+70058
+63553
+3974
+51359
+54768
+56514
+36525
+64585
+27027
+6948
+5464
+47226
+13217
+62960
+25701
+69692
+29942
+26502
+36651
+1591
+36023
+35774
+25901
+8171
+44558
+52
+15664
+19096
+78547
+56889
+45647
+14903
+52030
+65874
+44307
+64975
+33793
+56257
+34857
+34846
+20711
+66876
+25118
+31895
+32366
+68431
+34032
+38405
+57450
+52192
+20563
+10314
+31659
+3204
+53978
+16995
+27526
+74018
+45513
+48555
+16163
+70998
+68387
+65345
+13757
+67647
+48633
+62813
+19473
+52391
+57986
+19400
+38452
+33140
+60945
+36873
+73426
+9707
+51330
+10062
+58809
+75163
+37190
+30660
+4742
+75838
+29744
+71827
+22011
+35369
+49125
+53653
+54214
+64567
+3716
+72797
+24322
+60476
+33840
+71895
+42547
+35997
+59654
+45844
+54311
+50293
+67385
+6218
+61096
+31111
+4206
+69379
+54531
+34483
+23259
+50386
+8879
+9821
+57116
+69547
+25373
+29969
+31660
+34503
+17120
+48321
+70244
+18056
+50105
+22849
+28174
+2368
+44320
+67124
+586
+74218
+47625
+54263
+8773
+63514
+58201
+41232
+61867
+31471
+56094
+2342
+4634
+70231
+15533
+18025
+63507
+20975
+74488
+30107
+47758
+67276
+74875
+5900
+1818
+73092
+45710
+57289
+21206
+78052
+8741
+16284
+34725
+65190
+13870
+22089
+41607
+55252
+66394
+24942
+17855
+61279
+1786
+32806
+70249
+25647
+75833
+45878
+42020
+30875
+15257
+32675
+39209
+51
+58655
+12457
+44140
+16611
+8770
+25531
+8161
+55431
+68143
+56929
+22020
+45964
+18953
+19308
+59888
+28680
+41313
+68640
+78474
+22069
+60773
+19510
+80291
+27982
+12397
+41441
+3872
+1564
+18326
+36957
+12947
+6766
+16470
+33858
+54592
+74726
+65741
+28713
+8347
+31179
+50910
+4774
+8271
+5735
+52638
+55055
+35454
+73313
+28155
+712
+73736
+50228
+51345
+7831
+56832
+74072
+8138
+33189
+20661
+46398
+15151
+68620
+16777
+54030
+64353
+51392
+2488
+12001
+45499
+54651
+21743
+56531
+19129
+57675
+55539
+40631
+36491
+69192
+53735
+30160
+50485
+4971
+24202
+18604
+13403
+12164
+10524
+9518
+2877
+36107
+78102
+20653
+21157
+65081
+309
+18002
+70974
+47077
+69415
+78255
+42517
+68486
+32751
+20353
+39780
+28133
+41578
+15011
+72168
+33238
+4115
+62444
+58391
+5631
+15776
+17845
+63752
+26333
+28833
+76971
+43396
+58884
+80351
+36297
+37337

Dockerfile

@@ -0,0 +1,21 @@
+# Use an official Python runtime as a parent image
+FROM python:3.7
+
+# Set the working directory to /app
+WORKDIR /app
+
+# Copy the current directory contents into the container at /app
+COPY . /app
+
+# Install any needed packages specified in requirements.txt
+RUN pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu117 -U
+RUN pip install django opencv-python scipy pandas shapely -U
+
+# Expose the port the app runs on
+EXPOSE 8000
+
+# Define environment variable
+ENV NAME g2p_app
+
+# Run app.py when the container launches
+CMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]

Graph2plan

@@ -0,0 +1 @@
+Subproject commit 3c6af231f52c38afaf4a0025ceffbc2e5afa7ada

Interface/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()

Interface/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 = ['*']

Interface/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),
+
+
+]

Interface/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()

Interface/Houseweb/admin.py

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

Interface/Houseweb/apps.py

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

Interface/Houseweb/models.py

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

Interface/Houseweb/tests.py

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

Interface/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

Interface/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

Interface/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
+

Interface/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

Interface/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

Interface/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