CellProfiler-nightly 5.0.0.dev554__tar.gz → 5.0.0.dev562__tar.gz

{cellprofiler_nightly-5.0.0.dev554 → cellprofiler_nightly-5.0.0.dev562}/CellProfiler_nightly.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: CellProfiler-nightly
-Version: 5.0.0.dev554
+Version: 5.0.0.dev562
 Summary: CellProfiler is a free open-source software designed to enable biologists without training in computer vision or programming to quantitatively measure phenotypes from thousands of images automatically.
 Author: Anne Carpenter, Thouis (Ray) Jones, Lee Kamentsky, Vebjorn Ljosa, David Logan, Mark Bray, Madison Swain-Bowden, Allen Goodman, Claire McQuinn, Alice Lucas, Callum Tromans-Coia
 Author-email: Beth Cimini <bcimini@broadinstitute.org>, David Stirling <dstirling@glencoesoftware.com>, Nodar Gogoberidze <ngogober@broadinstitute.org>

{cellprofiler_nightly-5.0.0.dev554 → cellprofiler_nightly-5.0.0.dev562}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: CellProfiler-nightly
-Version: 5.0.0.dev554
+Version: 5.0.0.dev562
 Summary: CellProfiler is a free open-source software designed to enable biologists without training in computer vision or programming to quantitatively measure phenotypes from thousands of images automatically.
 Author: Anne Carpenter, Thouis (Ray) Jones, Lee Kamentsky, Vebjorn Ljosa, David Logan, Mark Bray, Madison Swain-Bowden, Allen Goodman, Claire McQuinn, Alice Lucas, Callum Tromans-Coia
 Author-email: Beth Cimini <bcimini@broadinstitute.org>, David Stirling <dstirling@glencoesoftware.com>, Nodar Gogoberidze <ngogober@broadinstitute.org>

{cellprofiler_nightly-5.0.0.dev554 → cellprofiler_nightly-5.0.0.dev562}/cellprofiler/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '5.0.0.dev554'
-__version_tuple__ = version_tuple = (5, 0, 0, 'dev554')
+__version__ = version = '5.0.0.dev562'
+__version_tuple__ = version_tuple = (5, 0, 0, 'dev562')
 
-__commit_id__ = commit_id = 'g7151f72c8'
+__commit_id__ = commit_id = 'g9d892da07'

{cellprofiler_nightly-5.0.0.dev554 → cellprofiler_nightly-5.0.0.dev562}/cellprofiler/modules/measureobjectskeleton.py

@@ -60,11 +60,7 @@ Measurements made by this module
 """
 
 import os
-
-import centrosome.cpmorphology
-import centrosome.propagate as propagate
 import numpy
-import scipy.ndimage
 from cellprofiler_core.constants.measurement import COLTYPE_FLOAT
 from cellprofiler_core.constants.measurement import COLTYPE_INTEGER
 from cellprofiler_core.image import Image
@@ -82,31 +78,8 @@ from cellprofiler_core.setting.text import ImageName, Directory
 from cellprofiler_core.setting.text import Integer
 from cellprofiler_core.setting.text import Text
 from cellprofiler_core.utilities.core.object import size_similarly
-from centrosome.cpmorphology import fixup_scipy_ndimage_result as fix
-from scipy.ndimage import grey_dilation, grey_erosion
-
-"""The measurement category"""
-C_OBJSKELETON = "ObjectSkeleton"
-
-"""The trunk count feature"""
-F_NUMBER_TRUNKS = "NumberTrunks"
-
-"""The branch feature"""
-F_NUMBER_NON_TRUNK_BRANCHES = "NumberNonTrunkBranches"
-
-"""The endpoint feature"""
-F_NUMBER_BRANCH_ENDS = "NumberBranchEnds"
-
-"""The neurite length feature"""
-F_TOTAL_OBJSKELETON_LENGTH = "TotalObjectSkeletonLength"
-
-F_ALL = [
-    F_NUMBER_TRUNKS,
-    F_NUMBER_NON_TRUNK_BRANCHES,
-    F_NUMBER_BRANCH_ENDS,
-    F_TOTAL_OBJSKELETON_LENGTH,
-]
-
+from cellprofiler_library.opts.measureobjectskeleton import SkeletonMeasurements, C_OBJSKELETON, F_ALL, edge_file_columns, vertex_file_columns
+from cellprofiler_library.modules._measureobjectskeleton import measure_object_skeleton
 
 class MeasureObjectSkeleton(Module):
     module_name = "MeasureObjectSkeleton"
@@ -312,26 +285,6 @@ The file has the following columns:
         vertex_path = os.path.abspath(os.path.join(path, vertex_file))
         return edge_path, vertex_path
 
-    VF_IMAGE_NUMBER = "image_number"
-    VF_VERTEX_NUMBER = "vertex_number"
-    VF_I = "i"
-    VF_J = "j"
-    VF_LABELS = "labels"
-    VF_KIND = "kind"
-    vertex_file_columns = (
-        VF_IMAGE_NUMBER,
-        VF_VERTEX_NUMBER,
-        VF_I,
-        VF_J,
-        VF_LABELS,
-        VF_KIND,
-    )
-    EF_IMAGE_NUMBER = "image_number"
-    EF_V1 = "v1"
-    EF_V2 = "v2"
-    EF_LENGTH = "length"
-    EF_TOTAL_INTENSITY = "total_intensity"
-    edge_file_columns = (EF_IMAGE_NUMBER, EF_V1, EF_V2, EF_LENGTH, EF_TOTAL_INTENSITY)
 
     def prepare_run(self, workspace):
         """Initialize graph files"""
@@ -347,8 +300,8 @@ The file has the following columns:
             vertex_files.add(vertex_path)
 
         for file_path, header in (
-            (edge_path, self.edge_file_columns),
-            (vertex_path, self.vertex_file_columns),
+            (edge_path, edge_file_columns),
+            (vertex_path, vertex_file_columns),
         ):
             if os.path.exists(file_path):
                 import wx
@@ -368,6 +321,8 @@ The file has the following columns:
                 header = ",".join(header)
                 fd.write(header + "\n")
         return True
+    
+    
 
     def run(self, workspace):
         """Run the module on the image set"""
@@ -376,7 +331,6 @@ The file has the following columns:
         seed_objects = workspace.object_set.get_objects(seed_objects_name)
         labels = seed_objects.segmented
         labels_count = numpy.max(labels)
-        label_range = numpy.arange(labels_count, dtype=numpy.int32) + 1
 
         skeleton_image = workspace.image_set.get_image(
             skeleton_name, must_be_binary=True
@@ -389,211 +343,75 @@ The file has the following columns:
         except:
             labels, m1 = size_similarly(skeleton, labels)
             labels[~m1] = 0
-        #
-        # The following code makes a ring around the seed objects with
-        # the skeleton trunks sticking out of it.
-        #
-        # Create a new skeleton with holes at the seed objects
-        # First combine the seed objects with the skeleton so
-        # that the skeleton trunks come out of the seed objects.
-        #
-        # Erode the labels once so that all of the trunk branchpoints
-        # will be within the labels
-        #
-        #
-        # Dilate the objects, then subtract them to make a ring
-        #
-        my_disk = centrosome.cpmorphology.strel_disk(1.5).astype(int)
-        dilated_labels = grey_dilation(labels, footprint=my_disk)
-        seed_mask = dilated_labels > 0
-        combined_skel = skeleton | seed_mask
-
-        closed_labels = grey_erosion(dilated_labels, footprint=my_disk)
-        seed_center = closed_labels > 0
-        combined_skel = combined_skel & (~seed_center)
-        #
-        # Fill in single holes (but not a one-pixel hole made by
-        # a one-pixel image)
-        #
-        if self.wants_to_fill_holes:
-
-            def size_fn(area, is_object):
-                return (~is_object) and (area <= self.maximum_hole_size.value)
-
-            combined_skel = centrosome.cpmorphology.fill_labeled_holes(
-                combined_skel, ~seed_center, size_fn
-            )
-        #
-        # Reskeletonize to make true branchpoints at the ring boundaries
-        #
-        combined_skel = centrosome.cpmorphology.skeletonize(combined_skel)
-        #
-        # The skeleton outside of the labels
-        #
-        outside_skel = combined_skel & (dilated_labels == 0)
-        #
-        # Associate all skeleton points with seed objects
-        #
-        dlabels, distance_map = propagate.propagate(
-            numpy.zeros(labels.shape), dilated_labels, combined_skel, 1
-        )
-        #
-        # Get rid of any branchpoints not connected to seeds
-        #
-        combined_skel[dlabels == 0] = False
-        #
-        # Find the branchpoints
-        #
-        branch_points = centrosome.cpmorphology.branchpoints(combined_skel)
-        #
-        # Odd case: when four branches meet like this, branchpoints are not
-        # assigned because they are arbitrary. So assign them.
-        #
-        # .  .
-        #  B.
-        #  .B
-        # .  .
-        #
-        odd_case = (
-            combined_skel[:-1, :-1]
-            & combined_skel[1:, :-1]
-            & combined_skel[:-1, 1:]
-            & combined_skel[1, 1]
-        )
-        branch_points[:-1, :-1][odd_case] = True
-        branch_points[1:, 1:][odd_case] = True
-        #
-        # Find the branching counts for the trunks (# of extra branches
-        # emanating from a point other than the line it might be on).
-        #
-        branching_counts = centrosome.cpmorphology.branchings(combined_skel)
-        branching_counts = numpy.array([0, 0, 0, 1, 2])[branching_counts]
-        #
-        # Only take branches within 1 of the outside skeleton
-        #
-        dilated_skel = scipy.ndimage.binary_dilation(
-            outside_skel, centrosome.cpmorphology.eight_connect
+        max_hole_size = self.maximum_hole_size.value
+        fill_small_holes = self.wants_to_fill_holes.value
+        intensity_image = None
+        if self.wants_objskeleton_graph:
+            intensity_image = workspace.image_set.get_image(self.intensity_image_name.value, must_be_grayscale=True)
+
+        lib_res = measure_object_skeleton(
+            seed_objects_name,
+            skeleton_name,
+            skeleton,
+            labels,
+            labels_count,
+            fill_small_holes,
+            max_hole_size,
+            self.wants_objskeleton_graph.value,
+            intensity_image.pixel_data if intensity_image else None,
+            self.wants_branchpoint_image.value
         )
-        branching_counts[~dilated_skel] = 0
-        #
-        # Find the endpoints
-        #
-        end_points = centrosome.cpmorphology.endpoints(combined_skel)
-        #
-        # We use two ranges for classification here:
-        # * anything within one pixel of the dilated image is a trunk
-        # * anything outside of that range is a branch
-        #
-        nearby_labels = dlabels.copy()
-        nearby_labels[distance_map > 1.5] = 0
-
-        outside_labels = dlabels.copy()
-        outside_labels[nearby_labels > 0] = 0
-        #
-        # The trunks are the branchpoints that lie within one pixel of
-        # the dilated image.
-        #
-        if labels_count > 0:
-            trunk_counts = fix(
-                scipy.ndimage.sum(branching_counts, nearby_labels, label_range)
-            ).astype(int)
-        else:
-            trunk_counts = numpy.zeros((0,), int)
-        #
-        # The branches are the branchpoints that lie outside the seed objects
-        #
-        if labels_count > 0:
-            branch_counts = fix(
-                scipy.ndimage.sum(branch_points, outside_labels, label_range)
-            )
+        # rare case of not conditioning on self.show_window for display results here
+        # since we might need them even if/when show_window is False
+        if self.wants_branchpoint_image or self.wants_objskeleton_graph:
+            lib_measurements, lib_display = lib_res
         else:
-            branch_counts = numpy.zeros((0,), int)
-        #
-        # Save the endpoints
-        #
-        if labels_count > 0:
-            end_counts = fix(scipy.ndimage.sum(end_points, outside_labels, label_range))
-        else:
-            end_counts = numpy.zeros((0,), int)
-        #
-        # Calculate the distances
-        #
-        total_distance = centrosome.cpmorphology.skeleton_length(
-            dlabels * outside_skel, label_range
-        )
+            lib_measurements = lib_res
         #
         # Save measurements
         #
         m = workspace.measurements
         assert isinstance(m, Measurements)
-        feature = "_".join((C_OBJSKELETON, F_NUMBER_TRUNKS, skeleton_name))
-        m.add_measurement(seed_objects_name, feature, trunk_counts)
-        feature = "_".join((C_OBJSKELETON, F_NUMBER_NON_TRUNK_BRANCHES, skeleton_name))
-        m.add_measurement(seed_objects_name, feature, branch_counts)
-        feature = "_".join((C_OBJSKELETON, F_NUMBER_BRANCH_ENDS, skeleton_name))
-        m.add_measurement(seed_objects_name, feature, end_counts)
-        feature = "_".join((C_OBJSKELETON, F_TOTAL_OBJSKELETON_LENGTH, skeleton_name))
-        m[seed_objects_name, feature] = total_distance
+        
+        for object_name, features in lib_measurements.objects.items():
+            for feature_name, values in features.items():
+                m.add_measurement(object_name, feature_name, values)
+        
+        for feature_name, value in lib_measurements.image.items():
+             m.add_image_measurement(feature_name, value)
         #
         # Collect the graph information
         #
         if self.wants_objskeleton_graph:
-            trunk_mask = (branching_counts > 0) & (nearby_labels != 0)
-            intensity_image = workspace.image_set.get_image(
-                self.intensity_image_name.value
-            )
-            edge_graph, vertex_graph = self.make_objskeleton_graph(
-                combined_skel,
-                dlabels,
-                trunk_mask,
-                branch_points & ~trunk_mask,
-                end_points,
-                intensity_image.pixel_data,
-            )
-
-            image_number = workspace.measurements.image_set_number
-
             edge_path, vertex_path = self.get_graph_file_paths(m, m.image_number)
             workspace.interaction_request(
                 self,
                 m.image_number,
                 edge_path,
-                edge_graph,
+                lib_display.edge_graph,
                 vertex_path,
-                vertex_graph,
+                lib_display.vertex_graph,
                 headless_ok=True,
             )
 
             if self.show_window:
-                workspace.display_data.edge_graph = edge_graph
-                workspace.display_data.vertex_graph = vertex_graph
+                workspace.display_data.edge_graph = lib_display.edge_graph
+                workspace.display_data.vertex_graph = lib_display.vertex_graph
                 workspace.display_data.intensity_image = intensity_image.pixel_data
         #
         # Make the display image
         #
-        if self.show_window or self.wants_branchpoint_image:
-            branchpoint_image = numpy.zeros((skeleton.shape[0], skeleton.shape[1], 3))
-            trunk_mask = (branching_counts > 0) & (nearby_labels != 0)
-            branch_mask = branch_points & (outside_labels != 0)
-            end_mask = end_points & (outside_labels != 0)
-            branchpoint_image[outside_skel, :] = 1
-            branchpoint_image[trunk_mask | branch_mask | end_mask, :] = 0
-            branchpoint_image[trunk_mask, 0] = 1
-            branchpoint_image[branch_mask, 1] = 1
-            branchpoint_image[end_mask, 2] = 1
-            branchpoint_image[dilated_labels != 0, :] *= 0.875
-            branchpoint_image[dilated_labels != 0, :] += 0.1
-            if self.show_window:
-                workspace.display_data.branchpoint_image = branchpoint_image
-            if self.wants_branchpoint_image:
-                bi = Image(branchpoint_image, parent_image=skeleton_image)
-                workspace.image_set.add(self.branchpoint_image_name.value, bi)
+        if self.show_window:
+            workspace.display_data.branchpoint_image = lib_display.branchpoint_image
+        if self.wants_branchpoint_image:
+            bi = Image(lib_display.branchpoint_image, parent_image=skeleton_image)
+            workspace.image_set.add(self.branchpoint_image_name.value, bi)
 
     def handle_interaction(
         self, image_number, edge_path, edge_graph, vertex_path, vertex_graph
     ):
         columns = tuple(
-            [vertex_graph[f].tolist() for f in self.vertex_file_columns[2:]]
+            [vertex_graph[f].tolist() for f in vertex_file_columns[2:]]
         )
         with open(vertex_path, "at") as fd:
             for vertex_number, fields in enumerate(zip(*columns)):
@@ -602,7 +420,7 @@ The file has the following columns:
                     + ("%d,%d,%d,%s\n" % fields)
                 )
 
-        columns = tuple([edge_graph[f].tolist() for f in self.edge_file_columns[1:]])
+        columns = tuple([edge_graph[f].tolist() for f in edge_file_columns[1:]])
         with open(edge_path, "at") as fd:
             line_format = "%d,%%d,%%d,%%d,%%.4f\n" % image_number
             for fields in zip(*columns):
@@ -654,7 +472,7 @@ The file has the following columns:
                 self.seed_objects_name.value,
                 "_".join((C_OBJSKELETON, feature, self.image_name.value)),
                 COLTYPE_FLOAT
-                if feature == F_TOTAL_OBJSKELETON_LENGTH
+                if feature == SkeletonMeasurements.TOTAL_OBJSKELETON_LENGTH
                 else COLTYPE_INTEGER,
             )
             for feature in F_ALL
@@ -722,202 +540,3 @@ The file has the following columns:
             ]
             variable_revision_number = 3
         return setting_values, variable_revision_number
-
-    def make_objskeleton_graph(
-        self, skeleton, skeleton_labels, trunks, branchpoints, endpoints, image
-    ):
-        """Make a table that captures the graph relationship of the skeleton
-
-        skeleton - binary skeleton image + outline of seed objects
-        skeleton_labels - labels matrix of skeleton
-        trunks - binary image with trunk points as 1
-        branchpoints - binary image with branchpoints as 1
-        endpoints - binary image with endpoints as 1
-        image - image for intensity measurement
-
-        returns two tables.
-        Table 1: edge table
-        The edge table is a numpy record array with the following named
-        columns in the following order:
-        v1: index into vertex table of first vertex of edge
-        v2: index into vertex table of second vertex of edge
-        length: # of intermediate pixels + 2 (for two vertices)
-        total_intensity: sum of intensities along the edge
-
-        Table 2: vertex table
-        The vertex table is a numpy record array:
-        i: I coordinate of the vertex
-        j: J coordinate of the vertex
-        label: the vertex's label
-        kind: kind of vertex = "T" for trunk, "B" for branchpoint or "E" for endpoint.
-        """
-        i, j = numpy.mgrid[0 : skeleton.shape[0], 0 : skeleton.shape[1]]
-        #
-        # Give each point of interest a unique number
-        #
-        points_of_interest = trunks | branchpoints | endpoints
-        number_of_points = numpy.sum(points_of_interest)
-        #
-        # Make up the vertex table
-        #
-        tbe = numpy.zeros(points_of_interest.shape, "|S1")
-        tbe[trunks] = "T"
-        tbe[branchpoints] = "B"
-        tbe[endpoints] = "E"
-        i_idx = i[points_of_interest]
-        j_idx = j[points_of_interest]
-        poe_labels = skeleton_labels[points_of_interest]
-        tbe = tbe[points_of_interest]
-        vertex_table = {
-            self.VF_I: i_idx,
-            self.VF_J: j_idx,
-            self.VF_LABELS: poe_labels,
-            self.VF_KIND: tbe,
-        }
-        #
-        # First, break the skeleton by removing the branchpoints, endpoints
-        # and trunks
-        #
-        broken_skeleton = skeleton & (~points_of_interest)
-        #
-        # Label the broken skeleton: this labels each edge differently
-        #
-        edge_labels, nlabels = centrosome.cpmorphology.label_skeleton(skeleton)
-        #
-        # Reindex after removing the points of interest
-        #
-        edge_labels[points_of_interest] = 0
-        if nlabels > 0:
-            indexer = numpy.arange(nlabels + 1)
-            unique_labels = numpy.sort(numpy.unique(edge_labels))
-            nlabels = len(unique_labels) - 1
-            indexer[unique_labels] = numpy.arange(len(unique_labels))
-            edge_labels = indexer[edge_labels]
-            #
-            # find magnitudes and lengths for all edges
-            #
-            magnitudes = fix(
-                scipy.ndimage.sum(
-                    image, edge_labels, numpy.arange(1, nlabels + 1, dtype=numpy.int32)
-                )
-            )
-            lengths = fix(
-                scipy.ndimage.sum(
-                    numpy.ones(edge_labels.shape),
-                    edge_labels,
-                    numpy.arange(1, nlabels + 1, dtype=numpy.int32),
-                )
-            ).astype(int)
-        else:
-            magnitudes = numpy.zeros(0)
-            lengths = numpy.zeros(0, int)
-        #
-        # combine the edge labels and indexes of points of interest with padding
-        #
-        edge_mask = edge_labels != 0
-        all_labels = numpy.zeros(numpy.array(edge_labels.shape) + 2, int)
-        all_labels[1:-1, 1:-1][edge_mask] = edge_labels[edge_mask] + number_of_points
-        all_labels[i_idx + 1, j_idx + 1] = numpy.arange(1, number_of_points + 1)
-        #
-        # Collect all 8 neighbors for each point of interest
-        #
-        p1 = numpy.zeros(0, int)
-        p2 = numpy.zeros(0, int)
-        for i_off, j_off in (
-            (0, 0),
-            (0, 1),
-            (0, 2),
-            (1, 0),
-            (1, 2),
-            (2, 0),
-            (2, 1),
-            (2, 2),
-        ):
-            p1 = numpy.hstack((p1, numpy.arange(1, number_of_points + 1)))
-            p2 = numpy.hstack((p2, all_labels[i_idx + i_off, j_idx + j_off]))
-        #
-        # Get rid of zeros which are background
-        #
-        p1 = p1[p2 != 0]
-        p2 = p2[p2 != 0]
-        #
-        # Find point_of_interest -> point_of_interest connections.
-        #
-        p1_poi = p1[(p2 <= number_of_points) & (p1 < p2)]
-        p2_poi = p2[(p2 <= number_of_points) & (p1 < p2)]
-        #
-        # Make sure matches are labeled the same
-        #
-        same_labels = (
-            skeleton_labels[i_idx[p1_poi - 1], j_idx[p1_poi - 1]]
-            == skeleton_labels[i_idx[p2_poi - 1], j_idx[p2_poi - 1]]
-        )
-        p1_poi = p1_poi[same_labels]
-        p2_poi = p2_poi[same_labels]
-        #
-        # Find point_of_interest -> edge
-        #
-        p1_edge = p1[p2 > number_of_points]
-        edge = p2[p2 > number_of_points]
-        #
-        # Now, each value that p2_edge takes forms a group and all
-        # p1_edge whose p2_edge are connected together by the edge.
-        # Possibly they touch each other without the edge, but we will
-        # take the minimum distance connecting each pair to throw out
-        # the edge.
-        #
-        edge, p1_edge, p2_edge = centrosome.cpmorphology.pairwise_permutations(
-            edge, p1_edge
-        )
-        indexer = edge - number_of_points - 1
-        lengths = lengths[indexer]
-        magnitudes = magnitudes[indexer]
-        #
-        # OK, now we make the edge table. First poi<->poi. Length = 2,
-        # magnitude = magnitude at each point
-        #
-        poi_length = numpy.ones(len(p1_poi)) * 2
-        poi_magnitude = (
-            image[i_idx[p1_poi - 1], j_idx[p1_poi - 1]]
-            + image[i_idx[p2_poi - 1], j_idx[p2_poi - 1]]
-        )
-        #
-        # Now the edges...
-        #
-        poi_edge_length = lengths + 2
-        poi_edge_magnitude = (
-            image[i_idx[p1_edge - 1], j_idx[p1_edge - 1]]
-            + image[i_idx[p2_edge - 1], j_idx[p2_edge - 1]]
-            + magnitudes
-        )
-        #
-        # Put together the columns
-        #
-        v1 = numpy.hstack((p1_poi, p1_edge))
-        v2 = numpy.hstack((p2_poi, p2_edge))
-        lengths = numpy.hstack((poi_length, poi_edge_length))
-        magnitudes = numpy.hstack((poi_magnitude, poi_edge_magnitude))
-        #
-        # Sort by p1, p2 and length in order to pick the shortest length
-        #
-        indexer = numpy.lexsort((lengths, v1, v2))
-        v1 = v1[indexer]
-        v2 = v2[indexer]
-        lengths = lengths[indexer]
-        magnitudes = magnitudes[indexer]
-        if len(v1) > 0:
-            to_keep = numpy.hstack(([True], (v1[1:] != v1[:-1]) | (v2[1:] != v2[:-1])))
-            v1 = v1[to_keep]
-            v2 = v2[to_keep]
-            lengths = lengths[to_keep]
-            magnitudes = magnitudes[to_keep]
-        #
-        # Put it all together into a table
-        #
-        edge_table = {
-            self.EF_V1: v1,
-            self.EF_V2: v2,
-            self.EF_LENGTH: lengths,
-            self.EF_TOTAL_INTENSITY: magnitudes,
-        }
-        return edge_table, vertex_table