Method remove_narrow

src/exterior-shell-extractor/main.py:622–680

(self, data)

    @utils.trace
    def remove_narrow(self, data):
        negate = lambda x: utils.to_opaque(utils.negate(-1)(x))
        
        astuple_nocopy = lambda dc: list(map(functools.partial(getattr, dc), map(operator.attrgetter('name'), fields(dc))))
        datas = [model_geometry(*map(lambda x: [x], xs)) for xs in zip(*astuple_nocopy(data))]
        by_elem_id = lambda i_d: i_d[1].convex_halfspace_trees[0][0].id()
        
        datas2 = [(k, list(vs)) for k, vs in itertools.groupby(sorted(enumerate(datas), key=by_elem_id), key=by_elem_id)]

        to_remove = []

        for i, rest in datas2:
            decomps = list(map(lambda d_i: d_i[1].convex_halfspace_trees[0][1], rest))
            orig_ids = list(map(lambda d_i: d_i[0], rest))
            # only tested on align inner
            assert all(len(parts) == 1 for parts in decomps)

            internal_mapping = []
            
            for j, parts in zip(orig_ids, decomps):

                hs = parts[0]
                epecks = [h.plane_equation() for h in hs.facets()]

                # print('I', original_index)
                # for eq in epecks:
                #     print('eq', *(x.to_string() for x in utils.to_tuple(eq)))

                rounded_negated = [tuple(-int(round(v * 10000)) for v in utils.to_double(eq)) for eq in epecks]
                # for v in rounded_negated:
                #     print('ap', *v)
                
                for eq in epecks:
                    try:
                        abcd_idx = rounded_negated.index(tuple(int(round(v * 10000)) for v in utils.to_double(eq)))
                    except ValueError as e:
                        continue
                    
                    internal_mapping.append((eq, negate(epecks[abcd_idx])))
                    internal_mapping.append((negate(eq), epecks[abcd_idx]))
                    to_remove.append(j)

                    # print('removing', original_index)
                    break
            
            for j, parts in zip(orig_ids, decomps):

                if j in to_remove:
                    continue
                    
                hs = parts[0]
                for ab in internal_mapping:
                    hs.map(*ab)

        datas_filtered = [d for i, d in enumerate(datas) if i not in to_remove]
        if not datas_filtered:
            return model_geometry()
        else: