first commit

Author: zzilch

batch_align.py

@@ -0,0 +1,47 @@
+import os
+import numpy as np
+from tqdm.auto import tqdm
+from rplan.floorplan import Floorplan
+from rplan.align import align_fp_gt
+from rplan.decorate import get_dw
+from rplan.utils import get_edges,savepkl,savemat
+from multiprocessing import Pool,Manager
+
+def func(file_path):
+    fp = Floorplan(file_path)
+    data = fp.to_dict(dtype=np.uint8)
+    boxes_aligned, order, room_boundaries = align_fp_gt(data['boundary'],data['boxes'],data['types'],data['edges'],dtype=np.uint8)
+    data['boxes_aligned'] = boxes_aligned
+    data['edges_aligned'] = np.array(get_edges(boxes_aligned),dtype=np.uint8)
+    data['order'] = order
+    return data
+
+class Callback():
+    def __init__(self,length):
+        self.bar = tqdm(total=length)
+        self.output = []
+
+    def update(self, ret):
+        self.output.append(ret)
+        self.bar.update(1)
+    
+    def close(self):
+        self.bar.close()
+    
+if __name__ == '__main__': 
+    img_dir = './data'
+    ids = os.listdir(img_dir)
+    ids = [f'{img_dir}/{i}' for i in ids]
+    print(len(ids))
+    with Manager() as manager:
+        with Pool(32) as pool:
+            cb = Callback(len(ids))
+            [pool.apply_async(func,args=(i,),callback=cb.update) for i in ids]
+            pool.close()
+            pool.join()
+            cb.close()
+            savepkl('./output/data_aligned.pkl',cb.output)
+            # for matlab
+            # savemat('./output/data_aligned.mat',{'data':cb.output}) 
+
+        

batch_decorate.py

@@ -0,0 +1,52 @@
+import os
+import numpy as np
+from tqdm.auto import tqdm
+from rplan.floorplan import Floorplan
+from rplan.align import align_fp_gt
+from rplan.decorate import get_dw
+from rplan.utils import get_edges,savepkl,savemat
+from multiprocessing import Pool,Manager
+
+def func(file_path):
+    fp = Floorplan(file_path)
+    data = fp.to_dict(dtype=np.uint8)
+    boxes_aligned, order, room_boundaries = align_fp_gt(data['boundary'],data['boxes'],data['types'],data['edges'],dtype=np.uint8)
+    data['boxes_aligned'] = boxes_aligned
+    data['edges_aligned'] = np.array(get_edges(boxes_aligned),dtype=np.uint8)
+    data['order'] = order
+    data['room_boundaries'] = room_boundaries
+    doors,windows = get_dw(data)
+    data['doors'] = doors
+    data['windows'] = windows
+    return data
+
+    
+class Callback():
+    def __init__(self,length):
+        self.bar = tqdm(total=length)
+        self.output = []
+
+    def update(self, ret):
+        self.output.append(ret)
+        self.bar.update(1)
+    
+    def close(self):
+        self.bar.close()
+    
+if __name__ == '__main__': 
+    img_dir = './data'
+    ids = os.listdir(img_dir)
+    ids = [f'{img_dir}/{i}' for i in ids]
+    print(len(ids))
+    with Manager() as manager:
+        with Pool(32) as pool:
+            cb = Callback(len(ids))
+            [pool.apply_async(func,args=(i,),callback=cb.update) for i in ids]
+            pool.close()
+            pool.join()
+            cb.close()
+            savepkl('./output/data_decorated.pkl',cb.output)
+            # for matlab
+            # savemat('./output/data_decorated.mat',{'data':cb.output})
+
+        

batch_save.py

@@ -0,0 +1,42 @@
+import os
+import numpy as np
+from tqdm.auto import tqdm
+from rplan.floorplan import Floorplan
+from rplan.align import align_fp_gt
+from rplan.utils import get_edges,savepkl,savemat
+from multiprocessing import Pool,Manager
+
+def func(file_path):
+    fp = Floorplan(file_path)
+    data = fp.to_dict(np.uint8)
+    return data
+    
+class Callback():
+    def __init__(self,length):
+        self.bar = tqdm(total=length)
+        self.output = []
+
+    def update(self, ret):
+        self.output.append(ret)
+        self.bar.update(1)
+    
+    def close(self):
+        self.bar.close()
+    
+if __name__ == '__main__': 
+    img_dir = './data'
+    ids = os.listdir(img_dir)
+    ids = [f'{img_dir}/{i}' for i in ids]
+    print(len(ids))
+    with Manager() as manager:
+        with Pool() as pool:
+            cb = Callback(len(ids))
+            [pool.apply_async(func,args=(i,),callback=cb.update) for i in ids]
+            pool.close()
+            pool.join()
+            cb.close()
+            savepkl('./output/data.pkl',cb.output)
+            # for matlab
+            # savemat('./output/data.mat',{'data':cb.output})
+
+        

data/0.png

@@ -0,0 +1,73 @@
+# RPLAN-ToolBox
+A tool box for RPLAN dataset.
+
+![](./output/plot.png)
+
+# Usage
+
+0. Install dependency
+
+    - python>=3.7
+
+    - matlab: [Install MATLAB Engine API for Python](https://www.mathworks.com/help/matlab/matlab_external/install-matlab-engine-api-for-python-in-nondefault-locations.html)
+
+    - numpy, scipy, scikit-image, matplotlib
+
+    - shapely, descartes
+
+
+1. Load a floorplan
+
+```python
+RPLAN_DIR = './data'
+file_path = f'{RPLAN_DIR}/0.png'
+fp = Floorplan(file_path)
+img = fp.image
+```
+
+2. Get image channels
+
+```python
+fp.boundary
+fp.category
+fp.instance
+fp.inside
+```
+
+2. Get vector graphics information
+```
+data = fp.to_dict()
+print(data.keys())
+```
+
+3. Align rooms with boundary, neighbors
+```
+from rplan.align import align_fp_gt
+boxes_aligned, order, room_boundaries = align_fp_gt(data['boundary'],data['boxes'],data['types'],data['edges'])
+data['boxes_aligned'] = boxes_aligned
+data['order'] = order
+data['room_boundaries'] = room_boundaries
+```
+
+4. Add doors and windows for a vector floorplan
+```
+from rplan.decorate import get_dw
+doors,windows = get_dw(data)
+data['doors'] = doors
+data['windows'] = windows
+``` 
+
+5. Plot floorplan
+```
+from rplan.plot import get_figure,get_axes
+from rplan.plot import plot_category,plot_boundary,plot_graph,plot_fp
+plot_category(fp.category) # raw image
+plot_boundary(data['boundary']) # vector boundary
+plot_graph(data['boundary'],data['boxes'],data['types'],data['edges']) # node graph
+plot_fp(data['boundary'], data['boxes_aligned'][order], data['types'][order]) # vector floorplan
+plot_fp(data['boundary'], data['boxes_aligned'][order], data['types'][order],data['doors'],data['windows']) # vector floorplan with doors and windows
+```
+
+## Acknowledgement
+- [RPLAN](http://staff.ustc.edu.cn/~fuxm/projects/DeepLayout/index.html)
+- [Graph2Plan](https://github.com/jizg/Graph2plan)

output/plot.png

@@ -0,0 +1,63 @@
+import numpy as np
+import matlab
+import matlab.engine as engine
+import os
+eng = engine.start_matlab()
+eng.addpath(os.path.join(os.path.dirname(__file__),'matlab'),nargout=0)
+
+GT_ThRESHOLD = 6
+PRED_ThRESHOLD = 12
+REFINE_ThRESHOLD = 18
+
+def align_fp(boundary, boxes, types, edges, image, threshold, dtype=int):
+    boundary = np.array(boundary,dtype=int).tolist()
+    boxes    = np.array(boxes,dtype=int).tolist()
+    types    = np.array(types,dtype=int).tolist()
+    edges    = np.array(edges,dtype=int).tolist()
+    image    = np.array(image,dtype=int).tolist()
+
+    boxes_aligned, order, room_boundaries = eng.align_fp(
+        matlab.double(boundary),
+        matlab.double(boxes),
+        matlab.double(types),
+        matlab.double(edges),
+        matlab.double(image),
+        threshold,False,nargout=3
+    )
+
+    boxes_aligned   = np.array(boxes_aligned,dtype=dtype)
+    order           = np.array(order,dtype=dtype).reshape(-1)-1
+    room_boundaries = np.array([np.array(rb,dtype=float) for rb in room_boundaries]) # poly with hole has value 'nan'
+
+    return boxes_aligned, order, room_boundaries
+
+def align_fp_gt(boundary, boxes, types, edges, dtype=int):
+    return align_fp(boundary, boxes, types, edges, [], GT_ThRESHOLD, dtype)
+
+def align_fp_gt2(eng, boundary, boxes, types, edges, dtype=int):
+    boundary = np.array(boundary,dtype=int).tolist()
+    boxes    = np.array(boxes,dtype=int).tolist()
+    types    = np.array(types,dtype=int).tolist()
+    edges    = np.array(edges,dtype=int).tolist()
+    image    = np.array([],dtype=int).tolist()
+
+    boxes_aligned, order, room_boundaries = eng.align_fp(
+        matlab.double(boundary),
+        matlab.double(boxes),
+        matlab.double(types),
+        matlab.double(edges),
+        matlab.double(image),
+        GT_ThRESHOLD,False,nargout=3
+    )
+    
+    boxes_aligned   = np.array(boxes_aligned,dtype=dtype)
+    order           = np.array(order,dtype=dtype).reshape(-1)-1
+    room_boundaries = np.array([np.array(rb,dtype=dtype) for rb in room_boundaries])
+
+    return boxes_aligned, order, room_boundaries
+
+def align_fp_coarse(boundary, boxes, types, edges, dtype=int):
+    return align_fp(boundary, boxes, types, edges, [], PRED_ThRESHOLD, dtype)
+
+def align_fp_fine(boundary, boxes, types, edges, image, dtype=int):
+    return align_fp(boundary, boxes, types, edges, image, REFINE_ThRESHOLD, dtype)

readme.md

@@ -0,0 +1,363 @@
+from skimage import io
+from skimage import morphology,feature,transform,measure
+from pathlib import Path
+from scipy import stats
+from scipy import ndimage
+from shapely import geometry
+import numpy as np
+
+from .utils import collide2d,point_box_relation,door_room_relation
+
+class Floorplan():
+
+    @property
+    def boundary(self): return self.image[...,0]
+    
+    @property
+    def category(self): return self.image[...,1]
+
+    @property
+    def instance(self): return self.image[...,2]
+    
+    @property
+    def inside(self): return self.image[...,3]
+
+    def __init__(self,file_path):
+        self.path = file_path
+        self.name = Path(self.path).stem
+        self.image = io.imread(self.path)
+        self.h,self.w,self.c = self.image.shape
+        
+        self.front_door = None
+        self.exterior_boundary = None
+        self.rooms = None
+        self.edges = None
+
+        self.archs = None
+        self.graph = None
+
+        self._get_front_door()
+        self._get_exterior_boundary()
+        self._get_rooms()
+        self._get_edges()
+        
+    def __repr__(self): 
+        return f'{self.name},({self.h},{self.w},{self.c})'
+
+    def _get_front_door(self):
+        front_door_mask = self.boundary==255
+        # fast bbox
+        # min_h,max_h = np.where(np.any(front_door_mask,axis=1))[0][[0,-1]]
+        # min_w,max_w = np.where(np.any(front_door_mask,axis=0))[0][[0,-1]]  
+        # self.front_door = np.array([min_h,min_w,max_h,max_w],dtype=int)
+        region = measure.regionprops(front_door_mask.astype(int))[0]
+        self.front_door = np.array(region.bbox,dtype=int)
+
+    def _get_exterior_boundary(self):
+        if self.front_door is None: self._get_front_door()
+        self.exterior_boundary = []
+
+        min_h,max_h = np.where(np.any(self.boundary,axis=1))[0][[0,-1]]
+        min_w,max_w = np.where(np.any(self.boundary,axis=0))[0][[0,-1]]
+        min_h = max(min_h-10,0)
+        min_w = max(min_w-10,0)
+        max_h = min(max_h+10,self.h)
+        max_w = min(max_w+10,self.w)
+
+        # src: http://staff.ustc.edu.cn/~fuxm/projects/DeepLayout/index.html
+        # search direction:0(right)/1(down)/2(left)/3(up)
+        # find the left-top point
+        flag = False
+        for h in range(min_h, max_h):
+            for w in range(min_w, max_w):
+                if self.inside[h, w] == 255:
+                    self.exterior_boundary.append((h, w, 0))
+                    flag = True
+                    break
+            if flag:
+                break
+        
+        # left/top edge: inside
+        # right/bottom edge: outside
+        while(flag):
+            if self.exterior_boundary[-1][2] == 0:
+                for w in range(self.exterior_boundary[-1][1]+1, max_w):
+                    corner_sum = 0
+                    if self.inside[self.exterior_boundary[-1][0], w] == 255:
+                        corner_sum += 1
+                    if self.inside[self.exterior_boundary[-1][0]-1, w] == 255:
+                        corner_sum += 1
+                    if self.inside[self.exterior_boundary[-1][0], w-1] == 255:
+                        corner_sum += 1
+                    if self.inside[self.exterior_boundary[-1][0]-1, w-1] == 255:
+                        corner_sum += 1
+                    if corner_sum == 1:
+                        new_point = (self.exterior_boundary[-1][0], w, 1)
+                        break
+                    if corner_sum == 3:
+                        new_point = (self.exterior_boundary[-1][0], w, 3)
+                        break
+            
+            if self.exterior_boundary[-1][2] == 1:      
+                for h in range(self.exterior_boundary[-1][0]+1, max_h): 
+                    corner_sum = 0                
+                    if self.inside[h, self.exterior_boundary[-1][1]] == 255:
+                        corner_sum += 1
+                    if self.inside[h-1, self.exterior_boundary[-1][1]] == 255:
+                        corner_sum += 1
+                    if self.inside[h, self.exterior_boundary[-1][1]-1] == 255:
+                        corner_sum += 1
+                    if self.inside[h-1, self.exterior_boundary[-1][1]-1] == 255:
+                        corner_sum += 1
+                    if corner_sum == 1:
+                        new_point = (h, self.exterior_boundary[-1][1], 2)
+                        break
+                    if corner_sum == 3:
+                        new_point = (h, self.exterior_boundary[-1][1], 0)
+                        break
+
+            if self.exterior_boundary[-1][2] == 2:   
+                for w in range(self.exterior_boundary[-1][1]-1, min_w, -1):
+                    corner_sum = 0                     
+                    if self.inside[self.exterior_boundary[-1][0], w] == 255:
+                        corner_sum += 1
+                    if self.inside[self.exterior_boundary[-1][0]-1, w] == 255:
+                        corner_sum += 1
+                    if self.inside[self.exterior_boundary[-1][0], w-1] == 255:
+                        corner_sum += 1
+                    if self.inside[self.exterior_boundary[-1][0]-1, w-1] == 255:
+                        corner_sum += 1
+                    if corner_sum == 1:
+                        new_point = (self.exterior_boundary[-1][0], w, 3)
+                        break
+                    if corner_sum == 3:
+                        new_point = (self.exterior_boundary[-1][0], w, 1)
+                        break
+
+            if self.exterior_boundary[-1][2] == 3:       
+                for h in range(self.exterior_boundary[-1][0]-1, min_h, -1):
+                    corner_sum = 0                
+                    if self.inside[h, self.exterior_boundary[-1][1]] == 255:
+                        corner_sum += 1
+                    if self.inside[h-1, self.exterior_boundary[-1][1]] == 255:
+                        corner_sum += 1
+                    if self.inside[h, self.exterior_boundary[-1][1]-1] == 255:
+                        corner_sum += 1
+                    if self.inside[h-1, self.exterior_boundary[-1][1]-1] == 255:
+                        corner_sum += 1
+                    if corner_sum == 1:
+                        new_point = (h, self.exterior_boundary[-1][1], 0)
+                        break
+                    if corner_sum == 3:
+                        new_point = (h, self.exterior_boundary[-1][1], 2)
+                        break
+
+            if new_point != self.exterior_boundary[0]:
+                self.exterior_boundary.append(new_point)
+            else:
+                flag = False
+        self.exterior_boundary = [[r,c,d,0] for r,c,d in self.exterior_boundary]
+        
+        door_y1,door_x1,door_y2,door_x2 = self.front_door
+        door_h,door_w = door_y2-door_y1,door_x2-door_x1
+        is_vertical = door_h>door_w or door_h==1 # 
+
+        insert_index = None
+        door_index = None
+        new_p = []
+        th = 3
+        for i in range(len(self.exterior_boundary)):
+            y1,x1,d,_ = self.exterior_boundary[i]
+            y2,x2,_,_ = self.exterior_boundary[(i+1)%len(self.exterior_boundary)] 
+            if is_vertical!=d%2: continue
+            if is_vertical and (x1-th<door_x1<x1+th or x1-th<door_x2<x1+th): # 1:down 3:up
+                l1 = geometry.LineString([[y1,x1],[y2,x2]])    
+                l2 = geometry.LineString([[door_y1,x1],[door_y2,x1]])  
+                l12 = l1.intersection(l2)
+                if l12.length>0:
+                    dy1,dy2 = l12.xy[0] # (y1>y2)==(dy1>dy2)
+                    insert_index = i
+                    door_index = i+(y1!=dy1)
+                    if y1!=dy1: new_p.append([dy1,x1,d,1])
+                    if y2!=dy2: new_p.append([dy2,x1,d,1])
+            elif not is_vertical and (y1-th<door_y1<y1+th or y1-th<door_y2<y1+th):
+                l1 = geometry.LineString([[y1,x1],[y2,x2]])    
+                l2 = geometry.LineString([[y1,door_x1],[y1,door_x2]])  
+                l12 = l1.intersection(l2)
+                if l12.length>0:
+                    dx1,dx2 = l12.xy[1] # (x1>x2)==(dx1>dx2)
+                    insert_index = i
+                    door_index = i+(x1!=dx1)
+                    if x1!=dx1: new_p.append([y1,dx1,d,1])
+                    if x2!=dx2: new_p.append([y1,dx2,d,1])                
+
+        if len(new_p)>0:
+            self.exterior_boundary = self.exterior_boundary[:insert_index+1]+new_p+self.exterior_boundary[insert_index+1:]
+        self.exterior_boundary = self.exterior_boundary[door_index:]+self.exterior_boundary[:door_index]
+
+        self.exterior_boundary = np.array(self.exterior_boundary,dtype=int)
+
+    def _get_rooms(self):
+        rooms = []
+        regions = measure.regionprops(self.instance)
+        for region in regions:
+            c = stats.mode(self.category[region.coords[:,0],region.coords[:,1]])[0][0]
+            y0,x0,y1,x1 = np.array(region.bbox) 
+            rooms.append([y0,x0,y1,x1,c])
+        self.rooms = np.array(rooms,dtype=int)
+
+    def _get_edges(self,th=9):
+        if self.rooms is None: self._get_rooms()
+        edges = []
+        for u in range(len(self.rooms)):
+            for v in range(u+1,len(self.rooms)):
+                if not collide2d(self.rooms[u,:4],self.rooms[v,:4],th=th): continue
+                uy0, ux0, uy1, ux1, c1 = self.rooms[u]
+                vy0, vx0, vy1, vx1, c2 = self.rooms[v]
+                uc = (uy0+uy1)/2,(ux0+ux1)/2
+                vc = (vy0+vy1)/2,(vx0+vx1)/2
+                if ux0 < vx0 and ux1 > vx1 and uy0 < vy0 and uy1 > vy1:
+                    relation = 5 #'surrounding'
+                elif ux0 >= vx0 and ux1 <= vx1 and uy0 >= vy0 and uy1 <= vy1:
+                    relation = 4 #'inside'
+                else:
+                    relation = point_box_relation(uc,self.rooms[v,:4])
+                edges.append([u,v,relation])
+                
+        self.edges = np.array(edges,dtype=int)
+
+    def _get_archs(self):
+        '''
+        Interior doors
+        '''
+        archs = []
+        
+        # treat archs as instances
+        # index = len(self.rooms)+1
+
+        # for category in range(num_category,len(room_label)):
+        for category in [17]: # only get doors for building graphs
+            mask = (self.category==category).astype(np.uint8)
+
+            # distance transform -> threshold -> corner detection -> remove corner -> watershed -> label region
+            #distance = cv2.distanceTransform(mask,cv2.DIST_C,3)
+            distance = ndimage.morphology.distance_transform_cdt(mask)
+
+            # local_maxi = feature.peak_local_max(distance, indices=False) # line with one pixel
+            local_maxi = (distance>1).astype(np.uint8) 
+
+            # corner_measurement = feature.corner_shi_tomasi(local_maxi) # short lines will be removed
+            corner_measurement = feature.corner_harris(local_maxi) 
+
+            local_maxi[corner_measurement>0] = 0
+
+            markers = measure.label(local_maxi)
+
+            labels = morphology.watershed(-distance, markers, mask=mask, connectivity=8)
+            regions = measure.regionprops(labels)
+
+            for region in regions:
+                y0,x0,y1,x1 = np.array(region.bbox) 
+                archs.append([y0,x0,y1,x1,category])
+
+        self.archs = np.array(archs,dtype=int)
+
+    def _get_graph(self,th=9):
+        '''
+        More detail graph
+        '''
+        if self.rooms is None: self._get_rooms()
+        if self.archs is None: self._get_archs()
+        graph = []
+        door_pos = [[None,0] for i in range(len(self.rooms))]
+        edge_set = set()
+
+        # add accessible edges
+        doors = self.archs[self.archs[:,-1]==17]
+        for i in range(len(doors)):
+            bbox = doors[i,:4]
+            
+            # left <-> right
+            for row in range(bbox[0],bbox[2]):
+
+                u = self.instance[row,bbox[1]-1]-1
+                v = self.instance[row,bbox[3]+1]-1
+                if (u,v) in edge_set or (v,u) in edge_set:continue
+                if u>=0 and v>=0 and (u,v):
+                    edge_set.add((u,v))
+                    graph.append([u,v,None,1,i])
+
+            # up <-> down
+            for col in range(bbox[1],bbox[3]):
+                u = self.instance[bbox[0]-1,col]-1
+                v = self.instance[bbox[2]+1,col]-1
+                if (u,v) in edge_set or (v,u) in edge_set:continue
+                if u>=0 and v>=0 and (u,v):
+                    edge_set.add((u,v))
+                    graph.append([u,v,None,1,i])
+
+        # add adjacent edges
+        for u in range(len(self.rooms)):
+            for v in range(u+1,len(self.rooms)):
+                if (u,v) in edge_set or (v,u) in edge_set: continue
+
+                # collision detection
+                if collide2d(self.rooms[u,:4],self.rooms[v,:4],th=th):
+                    edge_set.add((u,v))
+                    graph.append([u,v,None,0,None])
+
+        # add edge relation
+        for i in range(len(graph)):
+            u,v,e,t,d = graph[i]
+            uy0, ux0, uy1, ux1 = self.rooms[u,:4]
+            vy0, vx0, vy1, vx1 = self.rooms[v,:4]
+            uc = (uy0+uy1)/2,(ux0+ux1)/2
+            vc = (vy0+vy1)/2,(vx0+vx1)/2
+
+            if ux0 < vx0 and ux1 > vx1 and uy0 < vy0 and uy1 > vy1:
+                relation = 5 #'surrounding'
+            elif ux0 >= vx0 and ux1 <= vx1 and uy0 >= vy0 and uy1 <= vy1:
+                relation = 4 #'inside'
+            else:
+                relation = point_box_relation(uc,self.rooms[v,:4])
+            
+            graph[i][2] = relation
+
+
+            if d is not None:
+                c_u = self.rooms[u,-1]
+                c_v = self.rooms[v,-1]
+
+                if c_u > c_v and door_pos[u][0] is None:
+                    room = u
+                else:
+                    room = v
+                door_pos[room][0]=d
+                
+
+                d_center = self.archs[d,:4]
+                d_center = (d_center[:2]+d_center[2:])/2.0
+
+                dpos =  door_room_relation(d_center,self.rooms[room,:4])
+                if dpos!=0: door_pos[room][1] = dpos
+        
+        self.graph = graph
+        self.door_pos = door_pos
+
+    def to_dict(self,xyxy=True,dtype=int):
+        '''
+        Compress data, notice:
+        !!! int->uint8: a(uint8)+b(uint8) may overflow !!!
+        '''
+        return {
+            'name'      :self.name,
+            'types'     :self.rooms[:,-1].astype(dtype),
+            'boxes'     :(self.rooms[:,[1,0,3,2]]).astype(dtype) 
+            if xyxy else self.rooms[:,:4].astype(dtype),
+            'boundary'  :self.exterior_boundary[:,[1,0,2,3]].astype(dtype)
+            if xyxy else self.exterior_boundary.astype(dtype),
+            'edges'     :self.edges.astype(dtype)
+        }
+
+if __name__ == "__main__":
+    pass

rplan/__init__,py

@@ -0,0 +1,121 @@
+function [newBox, constraint] = align_adjacent_room(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

rplan/align.py

@@ -0,0 +1,114 @@
+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
+solid = false;
+
+
+% 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_fp2(boundary, rBox, rType, [], [], 3, 0, solid);
+    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_fp2(boundary, newBox, rType, [], [], 3, 0, solid);
+    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_fp2(boundary, newBox, rType, [], [], 3, 0, solid);
+    title('Align with neighbors');
+end
+
+% 3. regularize fp, include crop using boundary, gap filling
+[newBox, order] = regularize_fp(newBox, boundary, rType, fp);
+
+% 4. generate the room polygons
+[newBox, rBoundary] = get_room_boundary(newBox, boundary, order);
+    
+if drawResult
+%     subplot(2,2,3)
+%     plot_fp2(boundary, newBox, rType, [], [], 3, 0, false);
+%     title('Regularize fp');
+    
+    subplot(2,2,4)
+    plot_fp2(boundary, newBox, rType, [], [], 3, 0, solid);
+    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
+

rplan/decorate.py

@@ -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_room(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

rplan/floorplan.py

@@ -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

rplan/matlab/align_adjacent_room.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

rplan/matlab/align_fp.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

rplan/matlab/align_neighbor.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
+    

rplan/matlab/align_with_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

rplan/matlab/find_close_seg.m

@@ -0,0 +1,106 @@
+function [newBox, order] = refine_fp(boundary, rNode, rEdge, rBox, fp, threshold, drawResult, figName)
+% align the neighboring rooms first and then align with the boundary
+
+if nargin < 8
+    drawResult =false;
+end
+
+
+% pre-processing: 
+% move the edge relation w.r.t. living room to the end
+livingIdx = find(rNode(:,4)==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(3,4,1)
+    plot_fp(rBox, boundary, rNode, 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, rNode);
+
+if drawResult
+    subplot(3,4,2)
+    plot_fp(newBox, boundary, rNode, entranceBox);
+    title('Align with boundary');
+end
+
+
+% 2. for each adjacent pair of room,
+[~, newBox, ~] = align_neighbor(newBox, rEdge, updated, threshold+6);
+if drawResult
+    subplot(3,4,3)
+    plot_fp(newBox, boundary, rNode, entranceBox);
+    title('Align with neighbors');
+end
+
+% 3. regularize fp, include crop using boundary, gap filling
+[newBox, order] = regularize_fp(newBox, boundary, rNode, fp);
+    
+if drawResult
+    subplot(3,4,4)
+    plot_fp(newBox(order,:), boundary, rNode(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
+

rplan/matlab/find_room_order.m

@@ -0,0 +1,130 @@
+function [box, order] = regularize_fp(box, boundary, rType, image)
+
+% 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
+             n1 = 0;
+             n2 = 0;
+             
+             if ~isempty(image) 
+                 % find the overlap region in the image and determine the order
+                 % based on the vote
+                 mask = poly2mask(inter.Vertices(:, 1), inter.Vertices(:, 2), size(image,1), size(image,2));
+                 n1 = nnz(image(mask) == rType(i));
+                 n2 = nnz(image(mask) == rType(j));
+             end
+
+             if n1 == n2  
+                 % if there is no difference in the voting, use area
+                 if area1 <= area2 
+                     orderM(i,j) = true;
+                 else
+                     orderM(j,i) = true;
+                 end
+             elseif n1 > n2
+                 orderM(i,j) = true;
+             elseif n1 < n2
+                 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
+    

rplan/matlab/get_entrance_space.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

rplan/matlab/get_room_boundary.m

@@ -0,0 +1,207 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib.patches as patches
+from shapely import geometry
+from descartes import PolygonPatch
+
+from .utils import room_label
+
+def get_color_map():
+    color = np.array([
+        [244,242,229], # living room
+        [253,244,171], # bedroom
+        [234,216,214], # kitchen
+        [205,233,252], # bathroom
+        [208,216,135], # balcony
+        [249,222,189], # Storage
+        [ 79, 79, 79], # exterior wall
+        [255,225, 25], # FrontDoor
+        [128,128,128], # interior wall
+        [255,255,255]
+    ],dtype=np.int64)
+    cIdx  = np.array([1,2,3,4,1,2,2,2,2,5,1,6,1,10,7,8,9,10])-1
+    return color[cIdx]
+cmap = get_color_map()/255.0
+
+def get_figure(size=512):
+    if np.array(size).size==1:
+        w,h = size,size
+    else:
+        w,h = size[0],size[1]
+    fig = plt.figure()
+    dpi = fig.get_dpi()
+    fig.set_size_inches(w/dpi,h/dpi)
+    fig.set_frameon(False)
+    return fig    
+
+def get_axes(size=512,fig=None,rect=[0,0,1,1]):
+    if fig is None: fig = get_figure(size)
+
+    ax = fig.add_axes(rect)
+    #ax.set_frame_on(False)
+    ax.set_aspect('equal')
+    ax.set_xlim([0,255])
+    ax.set_ylim([0,255])
+    ax.invert_yaxis()
+    ax.set_axis_off()
+    
+    return ax
+
+def plot_category(category,ax=None):
+    if ax is None: ax = get_axes()
+    img = np.ones((category.shape[0],category.shape[1],4))
+    img[...,:3] = cmap[category]
+    img[category==13,3] = 0
+    ax.imshow(img)
+    return ax
+
+def plot_boundary(boundary, wall_thickness=6,ax=None):
+    if ax is None: ax = get_axes()
+    
+    is_new = boundary[:,-1]==1
+    poly_boundary = geometry.Polygon(boundary[~is_new,:2])
+    ax.add_patch(PolygonPatch(poly_boundary,fc='none',ec=cmap[14],lw=wall_thickness))
+
+    door = boundary[:2,:2]
+    idx = np.argmin(np.sum(door,axis=-1), axis=0)
+    if idx==1: door = door[[1,0]]
+
+    ori = boundary[0,2]
+    if ori%2==0:
+        door = door+np.array([
+            [wall_thickness/4,0],[-wall_thickness/4,0]
+        ])
+    else:
+        door = door+np.array([
+            [0,wall_thickness/4],
+            [0,-wall_thickness/4]
+        ])
+    ax.plot(door[:,0],door[:,1],color=cmap[15],lw=wall_thickness+1)
+
+    return ax
+
+def plot_graph(boundary, boxes, types, edges, wall_thickness=6,with_boundary=True,ax=None):
+    if ax is None: ax = get_axes()
+
+    if with_boundary: plot_boundary(boundary,wall_thickness,ax)
+
+    boxes = boxes.astype(float)
+    r_node = np.zeros((len(boxes),3))
+    for k in range(len(boxes)):
+        r_node[k,:2] = (boxes[k,:2]+boxes[k,2:])/2
+        r_node[k,2] = (boxes[k,2]-boxes[k,0])*(boxes[k,3]-boxes[k,1])
+    
+    for i in range(len(edges)):
+        idx = edges[i,:2]
+        ax.plot(r_node[idx,0],r_node[idx,1],'-',color=[0.7,0.7,0.7],lw=wall_thickness/2)
+
+    is_new = boundary[:,-1]==1
+    poly_boundary = geometry.Polygon(boundary[~is_new,:2])
+    for i in range(len(r_node)):
+        s = round(10*r_node[i,2])/poly_boundary.area*3+wall_thickness*3
+        ax.plot(r_node[i,0],r_node[i,1],'o',mec=cmap[16],mfc=cmap[types[i]],ms=s)
+
+    return ax
+
+def plot_fp(boundary, boxes, types, doors=[], windows=[], wall_thickness=6, fontsize=0, keep_box=False, alpha=1.0, ax=None):
+    if ax is None: ax = get_axes()
+
+    is_new = boundary[:,-1]==1
+    poly_boundary = geometry.Polygon(boundary[~is_new,:2])
+    poly = dict()
+    
+    for k in range(len(boxes)):
+        poly_room = geometry.box(*boxes[k])
+        poly[k] = poly_boundary.intersection(poly_room)
+        if poly[k].area==0: 
+            print(f'ploting empty box {k}!') 
+            continue
+
+        if keep_box:
+            poly[k] = geometry.box(*poly[k].bounds)
+            x,y = poly[k].exterior.xy
+            ax.fill(x,y,fc=cmap[types[k]],ec=cmap[16],alpha=alpha,lw=wall_thickness)
+        else:
+            if poly[k].geom_type!='Polygon':
+                for p in poly[k]:
+                    if p.geom_type!='Polygon': continue
+                    ax.add_patch(PolygonPatch(p,fc=cmap[types[k]],ec=cmap[16],alpha=alpha,lw=wall_thickness))
+            else:
+                ax.add_patch(PolygonPatch(poly[k],fc=cmap[types[k]],ec=cmap[16],alpha=alpha,lw=wall_thickness))
+
+    plot_boundary(boundary,wall_thickness,ax)
+
+    if len(doors)>0:
+        plot_door(doors, wall_thickness/3, ax)
+    if len(windows)>0:
+        plot_window(windows, wall_thickness/3, ax)
+
+    if fontsize!=0:         
+        for k in range(len(boxes)):
+            if poly[k].area==0: continue
+            cx, cy = poly[k].centroid.x,poly[k].centroid.y
+            ax.text(cx, cy, room_label[types[k]][1], fontsize=fontsize,horizontalalignment='center',verticalalignment='center')
+    
+    return ax
+
+def plot_window(windows, thickness=2, ax=None):
+    if ax is None: ax = get_axes()
+    for k in range(len(windows)):
+        window = windows[k]
+        seg = np.zeros((2,2))
+        seg[0] = window[1:3]
+        seg[1] = window[1:3]+ window[3:5]
+    
+        box = np.concatenate([seg.min(0),seg.max(0)],axis=-1)
+
+        if window[3] < window[4]:
+            box = box + np.array([-1,0,1,0]) * thickness
+            if window[4] > 0:
+                box[1] = box[1] + thickness
+                seg[0,1] = seg[0,1] + thickness
+            else:
+                box[3] = box[3] - thickness
+                seg[0,1] = seg[0,1] - thickness
+        else:
+            box = box + np.array([0,-1,0,1]) * thickness
+            if window[3] > 0:
+                box[0] = box[0] + thickness
+                seg[0,0] = seg[0,0] + thickness
+            else:
+                box[2] = box[2] - thickness
+                seg[0,0] = seg[0,0] - thickness
+        
+        ax.fill(box[[0,0,2,2,0]], box[[1,3,3,1,1]], 'w')
+        
+        ax.plot(box[[0,0,2,2,0]], box[[1,3,3,1,1]], color=[0.4,0.4,0.4], lw=1)
+        ax.plot(seg[:,0], seg[:,1], color=[0.4,0.4,0.4], lw=1)
+    
+    return ax
+
+def plot_door(doors, thickness, ax=None):
+    if ax is None: ax = get_axes()
+    for k in range(len(doors)):
+        door = doors[k]
+        seg = np.zeros((2,2))
+        seg[0] = door[1:3]
+        seg[1] = door[1:3]+ door[3:5]
+    
+        box = np.concatenate([seg.min(0),seg.max(0)],axis=-1)
+
+        if door[3] < door[4]:
+            box = box + np.array([-1,0,1,0]) * thickness
+            if door[4] > 0:
+                box[1] = box[1] + thickness
+            else:
+                box[3] = box[3] - thickness
+        else:
+            box = box + np.array([0,-1,0,1]) * thickness
+            if door[3] > 0:
+                box[0] = box[0] + thickness
+            else:
+                box[2] = box[2] - thickness
+        
+        ax.fill(box[[0,0,2,2,0]], box[[1,3,3,1,1]], 'w', ec=cmap[16])
+
+    return ax
+        

rplan/matlab/refine_fp.m

@@ -0,0 +1,149 @@
+import numpy as np
+import scipy.io as sio
+import pickle
+
+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")]
+    
+def savemat(file_path,data):
+    sio.savemat(file_path,data)
+
+def loadmat(file_path):
+    return sio.loadmat(file_path, squeeze_me=True, struct_as_record=False)
+
+def savepkl(file_path,data):
+    pickle.dump(data,open(file_path,'wb'))
+
+def loadpkl(file_path):
+    return pickle.load(open(file_path,'rb'))
+
+def get_color_map():
+    color = np.array([
+        [244,242,229], # living room
+        [253,244,171], # bedroom
+        [234,216,214], # kitchen
+        [205,233,252], # bathroom
+        [208,216,135], # balcony
+        [185,231,168], # balcony
+        [249,222,189], # Storage
+        [ 79, 79, 79], # exterior wall
+        [255,225, 25], # FrontDoor
+        [128,128,128], # interior wall
+        [255,255,255]
+    ],dtype=np.int64)
+    cIdx  = np.array([1,2,3,4,1,2,2,2,2,5,1,6,1,10,7,8,9,10])-1
+    return color[cIdx]
+
+def collide2d(bbox1, bbox2, th=0):
+    return not(
+        (bbox1[0]-th > bbox2[2]) or
+        (bbox1[2]+th < bbox2[0]) or
+        (bbox1[1]-th > bbox2[3]) or
+        (bbox1[3]+th < bbox2[1])
+    )
+
+edge_type = ['left-above',
+    'left-below',
+    'left-of',
+    'above',
+    'inside',
+    'surrounding',
+    'below',
+    'right-of',
+    'right-above',
+    'right-below']
+
+def point_box_relation(u,vbox):
+    uy,ux = u
+    vy0, vx0, vy1, vx1 = vbox
+    if (ux<vx0 and uy<=vy0) or (ux==vx0 and uy==vy0):
+        relation = 0 # 'left-above'
+    elif (vx0<=ux<vx1 and uy<=vy0):
+        relation = 3 # 'above'
+    elif (vx1<=ux and uy<vy0) or (ux==vx1 and uy==vy0):
+        relation = 8 # 'right-above'
+    elif (vx1<=ux and vy0<=uy<vy1):
+        relation = 7 # 'right-of'
+    elif (vx1<ux and vy1<=uy) or (ux==vx1 and uy==vy1):
+        relation = 9 # 'right-below'
+    elif (vx0<ux<=vx1 and vy1<=uy):
+        relation = 6 # 'below'
+    elif (ux<=vx0 and vy1<uy) or (ux==vx0 and uy==vy1):
+        relation = 1 # 'left-below'
+    elif(ux<=vx0 and vy0<uy<=vy1):
+        relation = 2 # 'left-of'
+    elif(vx0<ux<vx1 and vy0<uy<vy1):
+        relation = 4 # 'inside'
+
+    return relation
+
+def get_edges(boxes,th=9):
+    edges = []
+    for u in range(len(boxes)):
+        for v in range(u+1,len(boxes)):
+            if not collide2d(boxes[u,:4],boxes[v,:4],th=th): continue
+            uy0, ux0, uy1, ux1 = boxes[u,:4].astype(int)
+            vy0, vx0, vy1, vx1 = boxes[v,:4].astype(int)
+            uc = (uy0+uy1)/2,(ux0+ux1)/2
+            vc = (vy0+vy1)/2,(vx0+vx1)/2
+            if ux0 < vx0 and ux1 > vx1 and uy0 < vy0 and uy1 > vy1:
+                relation = 5 #'surrounding'
+            elif ux0 >= vx0 and ux1 <= vx1 and uy0 >= vy0 and uy1 <= vy1:
+                relation = 4 #'inside'
+            else:
+                relation = point_box_relation(uc,boxes[v,:4])
+            edges.append([u,v,relation])
+            
+    edges = np.array(edges,dtype=int)
+    return edges
+
+door_pos = [
+    'nan',
+    'bottom',
+    'bottom-right','right-bottom',
+    'right',
+    'right-top','top-right',
+    'top',
+    'top-left','left-top',
+    'left',
+    'left-bottom','bottom-left'
+]
+
+def door_room_relation(d_center,r_box):
+    y0,x0,y1,x1 = r_box
+    yc,xc = (y1+y0)/2, (x0+x1)/2
+    y,x = d_center
+    
+    if x==xc and y<yc:return 7
+    elif x==xc and y>yc:return 1
+    elif y==yc and x<xc:return 10
+    elif y==yc and x>xc:return 4
+    elif x0<x<xc:
+        if y<yc:return 8
+        else:return 12
+    elif xc<x<x1:
+        if y<yc:return 6
+        else:return 2
+    elif y0<y<yc:
+        if x<xc:return 9
+        else:return 5
+    elif yc<y<y1:
+        if x<xc:return 11
+        else:return 3
+    else:return 0

rplan/matlab/regularize_fp.m

@@ -0,0 +1,29 @@
+import matplotlib.pyplot as plt
+
+from rplan.floorplan import Floorplan
+from rplan.align import align_fp_gt
+from rplan.decorate import get_dw
+from rplan.plot import get_figure,get_axes,plot_category,plot_boundary,plot_graph,plot_fp
+
+RPLAN_DIR = './data'
+file_path = f'{RPLAN_DIR}/0.png'
+fp = Floorplan(file_path)
+data = fp.to_dict()
+
+boxes_aligned, order, room_boundaries = align_fp_gt(data['boundary'],data['boxes'],data['types'],data['edges'])
+data['boxes_aligned'] = boxes_aligned
+data['order'] = order
+data['room_boundaries'] = room_boundaries
+
+doors,windows = get_dw(data)
+data['doors'] = doors
+data['windows'] = windows
+
+fig = get_figure([512,512])
+plot_boundary(data['boundary'],ax=get_axes(fig=fig,rect=[0,0.5,0.5,0.5]))
+ax = plot_category(fp.category,ax=get_axes(fig=fig,rect=[0.5,0.5,0.5,0.5]))
+plot_graph(data['boundary'],data['boxes'],data['types'],data['edges'],ax=ax)
+plot_fp(data['boundary'], data['boxes_aligned'][order], data['types'][order],ax=get_axes(fig=fig,rect=[0,0,0.5,0.5]))
+plot_fp(data['boundary'], data['boxes_aligned'][order], data['types'][order],data['doors'],data['windows'],ax=get_axes(fig=fig,rect=[0.5,0,0.5,0.5]))
+fig.canvas.draw()
+fig.canvas.print_figure('./output/plot.png')