Connecting wall endpoints

It is not quite clear what your final goal is. Which of the lines do you want to cut? All loose ends or just the ones that are a little bit too long? And what about the different thicknesses of the lines?

The simplest thing I came up with is to convert the walls to lines with a specific width and than to discretize the end points of those lines, this way the resulting image looks a little bit cleaner:

import matplotlib.pyplot as plt
import numpy as np


def walls2lines(walls):
    lines = []
    widths = []
    for w in walls:
        x0, y0, x1, y1 = w
        if (x1-x0) > (y1 - y0):
            widths.append(y1-y0)
            lines.append(((x0, y0 + widths[-1] / 2), (x1, y0 + widths[-1] / 2)))
        else:
            widths.append(x1-x0)
            lines.append(((x0 + widths[-1] / 2, y0), (x0 + widths[-1] / 2, y1)))

    return np.array(lines), np.array(widths)


def discretize_np(x, step):
    difference = x % step  # distance to the next discrete value
    difference[difference > step / 2] -= step  # round correctly
    return x - difference


lines, widths = walls2lines(walls=walls)
lines = discretize_np(lines, step=50)
widths *= 10 / widths.max()

fig = plt.figure()
ax = fig.subplots()

for l, w in zip(lines, widths):
    ax.plot(*l.T, lw=w, alpha=0.5)

Another possibility is to really look at the overlaps of different rectangles and try to shift the respecting boundaries. But you have so many different cases that it is hard to find a good general solution and it really depends on what you are looking for.

I added an eps to walls2overlap to also include rectangles that do not quite intersect. And I commented a line to handle the free ends differently. A lot of fine tuning and trial and error...

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.patches import Rectangle
from matplotlib.collections import PatchCollection


def walls2overlap(walls, eps=0):

    idx_overlap = np.ones((len(walls), len(walls)), dtype=bool)
    for i, w_i in enumerate(walls):
        for j, w_j in enumerate(walls):
            (x0_i, x1_i), (y0_i, y1_i) = w_i
            (x0_j, x1_j), (y0_j, y1_j) = w_j
            if (x0_i > x1_j+eps or x1_i < x0_j-eps or
                y0_i > y1_j+eps or y1_i < y0_j-eps):
                idx_overlap[i, j] = False

    return idx_overlap


def get_orientations(walls):
    """
    0: horizontal, 1: vertical
    """
    (x0, x1), (y0, y1) = walls.transpose(1, 2, 0)
    return ((x1 -x0) < (y1 - y0)).astype(int)


def cut_walls(walls, idx_overlap):
    """Move the walls to the most extreme boundary
     of all intersecting walls of different orientation."""
    for i, w_i in enumerate(walls):
        o_i = orientations[i]
        idx_temp = np.logical_and(idx_overlap[i], orientations != o_i)
        if idx_temp.sum() <= 0:  # Set to 1, to keep free ended walls
            continue
        walls[i, o_i, 0] = np.min(walls[idx_temp, o_i, 0])
        walls[i, o_i, 1] = np.max(walls[idx_temp, o_i, 1])

    return walls


walls = np.reshape(walls, (-1, 2, 2), order='F')
idx_overlap = walls2overlap(walls=walls, eps=10)
orientations = get_orientations(walls)
walls = cut_walls(walls=walls, idx_overlap=idx_overlap)

fig, ax = new_fig(aspect=1)
rects = [Rectangle(xy=w[:, 0], width=w[0, 1] - w[0, 0], height=w[1, 1] - w[1, 0])
         for w in walls]
ax.add_collection(PatchCollection(rects, color='k', alpha=0.5))