I would suggest something like:

• consider the plan as a grid

• replace all alphabetic letters (and parenthesis) with spaces

• set as wall every cell with a non-space char

• set the 1st non-wall cell as room 1

  • loop over cells that are "air" near this one and set them as same room and loop over neightboring cells again and again untill you find walls
  • when done, take a remaining cell and set it as room X

do again and again until all cells are attributed to different rooms

• compare the original plan (that have letters) with the given rooms you found

Assuming the below as I am inferring it from the (very short and unclear) problem statement (please inform if these are true). Answer is directional at best.

1. ASCII plan is stored in txt file in local machine and needs to be read from software interface
2. The plan will always be rectangular as the solution does not incorporate any other shape
3. the ASCII chanrecters that represent the wall (| and / and and -) corners (+)
4. Rooms will always be named in round brackets and will not spill outside room and will not be written overlapping a wall or outside the room

Heuristic

The search of a room and the room name is based on BFS algorithm which one can understand using this arcticle https://medium.com/geekculture/breadth-first-search-bfs-algorithm-with-python-952aea707e93

Python Solution

importing numpy and reading the file from the location on local machine. Maxlength is the length of the rectagular plan

floor_plan = []; 
maxlength = 0;

Now we need to read the whole plan so as to have an object on which we will run the BFS

with open('txtfilewithASCIIplan.txt',encoding='utf-8-sig') as file:
    for line in file.read().splitlines():
        line_list = list(line)
        if(len(line_list) > maxlength):
            maxlength = len(line_list)
        floor_plan.append(line_list)

Create the object now

for _,row in enumerate(floor_plan):
    row.extend(list(' '*(maxlength - len(row))))

create the variables to be used in the BFS as described below. Comments are self explainatory

# seperator characters
seperator = {'+', '-', '|', '/', '\'}

#Number of Rows
number_of_rows = len(floor_plan)

#Number of Columns
number_of_columns = len(floor_plan[0])

#Matrix to keep track of points visited
visited = np.zeros(shape=(number_of_rows, number_of_columns), dtype=bool)

# contains a list of tuples; where the first element in tuple is room name and the second element is list of chairs in that room
room_with_chairs = []

# we store all the chairs present in the whole floor plan
list_of_all_letters = []

Do not visit a visited cell or a seperator

def shouldvisit(cell):
    x = cell[0]
    y = cell[1]
    return not(visited[x][y] or (floor_plan[x][y] in seperator))

A sense check for seeing if we are in a diagonal corner which is essentially a Checks if both given cells contain separators

def are_both_separators(cell1, cell2):
    return (floor_plan[cell1[0]][cell1[1]] in seperator) and (floor_plan[cell2[0]][cell2[1]] in seperator)

BFS needs to know its neighbours and we collect them here

# gets all the valid adjacent cells which can be at most 8
def get_neighbours(cell):
    x = cell[0]
    y = cell[1]
    neighbours = []

    # check for floor plan boundary
    y_0 = y > 0 #check if current position is not along left-most verticle edge of floor plan
    y_max = y < number_of_columns - 1 #check if current position is not along right-most verticle edge of floor plan
    x_0 = x > 0 #check if current position is not along top-most horizontal edge of floor plan
    x_max = x < number_of_rows - 1 #check if current position is not along bottom-most horizontal edge of floor plan

    # Below is the check for valid neighbours
    # The second condition is necessary because while checking a diagonal neighbour, we must make sure that
    # the cells along the other diagonal do not contain separators as in that case the diagonal neighbour would be on the other side of the boundary
    
    #check validity of i-1,j-1 & i-1,j+1
    if(x_0):

        if(y_0 and not are_both_separators((x-1, y), (x, y-1))):
            neighbours.append((x-1, y-1))
        neighbours.append((x-1, y))
        if(y_max) and not are_both_separators((x-1, y), (x, y+1)):
            neighbours.append((x-1, y+1))

    #check validity of i,j-1
    if(y_0):
        neighbours.append((x, y-1))

    #check validity of i,j+1
    if(y_max):
        neighbours.append((x, y+1))

    ##check validity of i+1,j-1 & i+1,j & i+1,j+1
    if(x_max):
        if(y_0 and not are_both_separators((x+1, y), (x, y-1))):
            neighbours.append((x+1, y-1))
        neighbours.append((x+1, y))
        
        if(y_max and not are_both_separators((x+1, y), (x, y+1))):
            neighbours.append((x+1, y+1))
    
    return neighbours

Now we search for the name of the room

def get_room_name(cell):
    x = cell[0]
    y = cell[1]
    row = ''.join(floor_plan[x]) #for string conversion
    l=y;
    r=y;
    while(l>0 and row[l]!='('):
        l-=1;
    while(r<len(row)-1 and row[r]!=')'):
        r+=1;
    return row[l+1:r]

BFS

def bfs(cell):
    queue = [cell]
    chairs = []
    area_name = None
    visited[cell[0]][cell[1]] = True    
    
    while(queue != []):
        curr_cell = queue.pop()
        x = curr_cell[0]
        y = curr_cell[1]

        curr_char = floor_plan[x][y]
        if(curr_char.isupper()):
            chairs.append(curr_char)

        elif((curr_char.islower() or curr_char == '(' or curr_char == ')') and area_name == None):
            area_name = get_room_name(curr_cell)

        for neighbour in get_neighbours(curr_cell):
            if(shouldvisit(neighbour)):
                visited[neighbour[0]][neighbour[1]] = True
                queue.append(neighbour)
    return (area_name, chairs)

Now running the BFS on the plan

# Doing BFS over every unvisited non-separator cell
for i, row in enumerate(floor_plan):
    for j, _ in enumerate(row):
        if(shouldvisit((i, j))):
            local_outcome = bfs((i, j))
            if(local_outcome[0] != None):
                room_with_chairs.append(local_outcome)
                list_of_all_letters.extend(local_outcome[1])

This completes the identification