diff --git a/docs/reference/drawing.rst b/docs/reference/drawing.rst
index 1434d36a..fc6862a3 100644
--- a/docs/reference/drawing.rst
+++ b/docs/reference/drawing.rst
@@ -21,6 +21,7 @@ Chimera Graph Functions
 
    chimera_layout
    draw_chimera
+   chimera_node_placer_2d
 
 Example
 ~~~~~~~
@@ -89,8 +90,6 @@ of nodes of a simple 5-node graph on a small Pegasus lattice.
 	             edge_list=[(4, 40), (4, 41), (4, 42), (4, 43)])
    >>> # Show graph H on a small Pegasus lattice
    >>> plt.ion()
-   >>> # Show graph H on a small Pegasus lattice
-   >>> plt.ion()
    >>> dnx.draw_pegasus(G, with_labels=True, crosses=True, node_color="Yellow")
    >>> dnx.draw_pegasus(H, crosses=True, node_color='b', style='dashed',
 	         edge_color='b', width=3)
@@ -141,3 +140,18 @@ of a five-node clique on a small Zephyr graph.
 	:alt: Five-node clique embedded in a small Zephyr graph.
 
 	Five-node clique embedded in a small Zephyr graph.
+
+
+Generic Plotting Functions
+--------------------------
+
+.. automodule:: dwave_networkx.drawing.qubit_layout
+
+.. autosummary::
+   :toctree: generated/
+
+   draw_qubit_graph
+   draw_embedding
+   draw_yield
+   normalize_size_and_aspect
+   draw_lineplot
diff --git a/dwave_networkx/drawing/chimera_layout.py b/dwave_networkx/drawing/chimera_layout.py
index 598f0332..b0b09278 100644
--- a/dwave_networkx/drawing/chimera_layout.py
+++ b/dwave_networkx/drawing/chimera_layout.py
@@ -20,14 +20,14 @@
 import networkx as nx
 from networkx import draw
 
-from dwave_networkx.drawing.qubit_layout import draw_qubit_graph, draw_embedding, draw_yield
+from dwave_networkx.drawing.qubit_layout import draw_qubit_graph, draw_embedding, draw_yield, normalize_size_and_aspect, draw_lineplot
 from dwave_networkx.generators.chimera import chimera_graph, find_chimera_indices, chimera_coordinates
 
 
 __all__ = ['chimera_layout', 'draw_chimera', 'draw_chimera_embedding', 'draw_chimera_yield']
 
 
-def chimera_layout(G, scale=1., center=None, dim=2):
+def chimera_layout(G, scale=1., center=None, dim=2, plot_kwargs=None):
     """Positions the nodes of graph G in a Chimera cross topology.
 
     NumPy (https://scipy.org) is required for this function.
@@ -51,6 +51,13 @@ def chimera_layout(G, scale=1., center=None, dim=2):
         Number of dimensions. When dim > 2, all extra dimensions are
         set to 0.
 
+    plot_kwargs : None or dict (default None)
+        A dict of keyword arguments to be used in a plotting function (see
+        :func:`networkx.drawing.nx_pylab.draw` and :func:`draw_lineplot`), to scale node and edge
+        sizes appropriately to the graph `G`.  Optional keys in ``plot_kwargs``
+        are set to default values by the :func:`normalize_size_and_aspect`
+        function. Do nothing if ``plot_kwargs`` is None.
+
     Returns
     -------
     pos : dict
@@ -75,9 +82,9 @@ def chimera_layout(G, scale=1., center=None, dim=2):
         n = G.graph['columns']
         t = G.graph['tile']
         # get a node placement function
-        xy_coords = chimera_node_placer_2d(m, n, t, scale, center, dim)
+        xy_coords = chimera_node_placer_2d(m, n, t, scale, center, dim, plot_kwargs=plot_kwargs)
 
-        if G.graph.get('labels') == 'coordinate':
+        if G.graph['labels'] == 'coordinate':
             pos = {v: xy_coords(*v) for v in G.nodes()}
         elif G.graph.get('data'):
             pos = {v: xy_coords(*dat['chimera_index']) for v, dat in G.nodes(data=True)}
@@ -97,7 +104,7 @@ def chimera_layout(G, scale=1., center=None, dim=2):
         m = max(idx[0] for idx in chimera_indices.values()) + 1
         n = max(idx[1] for idx in chimera_indices.values()) + 1
         t = max(idx[3] for idx in chimera_indices.values()) + 1
-        xy_coords = chimera_node_placer_2d(m, n, t, scale, center, dim)
+        xy_coords = chimera_node_placer_2d(m, n, t, scale, center, dim, plot_kwargs=plot_kwargs)
 
         # compute our coordinates
         pos = {v: xy_coords(i, j, u, k) for v, (i, j, u, k) in chimera_indices.items()}
@@ -105,7 +112,7 @@ def chimera_layout(G, scale=1., center=None, dim=2):
     return pos
 
 
-def chimera_node_placer_2d(m, n, t, scale=1., center=None, dim=2):
+def chimera_node_placer_2d(m, n, t, scale=1., center=None, dim=2, plot_kwargs=None):
     """Generates a function that converts Chimera indices to x, y
     coordinates for a plot.
 
@@ -131,6 +138,13 @@ def chimera_node_placer_2d(m, n, t, scale=1., center=None, dim=2):
         Number of dimensions. When dim > 2, all extra dimensions are
         set to 0.
 
+    plot_kwargs : None or dict (default None)
+        A dict of keyword arguments to be used in a plotting function (see
+        :func:`networkx.drawing.nx_pylab.draw` and :func:`draw_lineplot`), to scale node and edge
+        sizes appropriately to the graph `G`.  Optional keys in ``plot_kwargs``
+        are set to default values by the :func:`normalize_size_and_aspect`
+        function.  Do nothing if ``plot_kwargs`` is None.
+
     Returns
     -------
     xy_coords : function
@@ -141,10 +155,20 @@ def chimera_node_placer_2d(m, n, t, scale=1., center=None, dim=2):
     """
     import numpy as np
 
+    line_plot = False if plot_kwargs is None else plot_kwargs.get('line_plot')
+
+    center_pad = 0 if line_plot else 1
+    border_pad = 2
+
     tile_center = t // 2
-    tile_length = t + 3  # 1 for middle of cross, 2 for spacing between tiles
+    tile_length = t + border_pad + center_pad
+
     # want the enter plot to fill in [0, 1] when scale=1
-    scale /= max(m, n) * tile_length - 3
+    fabric_scale = max(m, n) * tile_length - border_pad - center_pad
+    scale /= fabric_scale
+
+    if plot_kwargs is not None:
+        normalize_size_and_aspect(fabric_scale, 200, plot_kwargs)
 
     grid_offsets = {}
 
@@ -153,10 +177,12 @@ def chimera_node_placer_2d(m, n, t, scale=1., center=None, dim=2):
     else:
         center = np.asarray(center)
 
-    paddims = dim - 2
-    if paddims < 0:
+    if dim < 2:
         raise ValueError("layout must have at least two dimensions")
 
+    # pad the dimensions beyond the second with zeros
+    paddims = np.zeros(dim - 2, dtype='float')
+
     if len(center) != dim:
         raise ValueError("length of center coordinates must match dimension of layout")
 
@@ -167,26 +193,37 @@ def _xy_coords(i, j, u, k):
         if k < tile_center:
             p = k
         else:
-            p = k + 1
+            p = k + center_pad
 
         if u:
-            xy = np.array([tile_center, -1 * p])
+            xy = np.array([tile_center, -1 * p], dtype='float')
         else:
-            xy = np.array([p, -1 * tile_center])
+            xy = np.array([p, -1 * tile_center], dtype='float')
 
         # next offset the corrdinates based on the which tile
         if i > 0 or j > 0:
             if (i, j) in grid_offsets:
                 xy += grid_offsets[(i, j)]
             else:
-                off = np.array([j * tile_length, -1 * i * tile_length])
+                off = np.array([j * tile_length, -1 * i * tile_length], dtype='float')
                 xy += off
                 grid_offsets[(i, j)] = off
 
         # convention for Chimera-lattice pictures is to invert the y-axis
-        return np.hstack((xy * scale, np.zeros(paddims))) + center
-
-    return _xy_coords
+        return np.hstack((xy * scale, paddims)) + center
+
+    if line_plot:
+        qubit_dx = np.hstack(([(t + 1)/2, 0], paddims)) * scale
+        qubit_dy = np.hstack(([0, (t + 1)/2], paddims)) * scale
+        def _line_coords(i, j, u, k):
+            xy = _xy_coords(i, j, u, k)
+            if u:
+                return np.vstack((xy - qubit_dx, xy + qubit_dx))
+            else:
+                return np.vstack((xy - qubit_dy, xy + qubit_dy))
+        return _line_coords
+    else:
+        return _xy_coords
 
 
 def draw_chimera(G, **kwargs):
@@ -209,6 +246,14 @@ def draw_chimera(G, **kwargs):
         form {edge: bias, ...}. Each bias should be numeric. Self-loop
         edges (i.e., :math:`i=j`) are treated as linear biases.
 
+    line_plot : boolean (optional, default False)
+        If ``line_plot`` is True, then qubits are drawn as line segments, and
+        edges are drawn either as line segments between qubits, or as circles
+        where two qubits overlap.  In this drawing style, the interpretation of
+        the ``width`` and ``node_size`` parameters (provided in ``kwargs``)
+        determine the area of the circles and line widths respectively.  See
+        :func:`dwave_networkx.qubit_layout.draw_lineplot` for more information.
+
     kwargs : optional keywords
        See networkx.draw_networkx() for a description of optional keywords,
        with the exception of the `pos` parameter which is not used by this
@@ -226,8 +271,8 @@ def draw_chimera(G, **kwargs):
     >>> plt.show()  # doctest: +SKIP
 
     """
-    draw_qubit_graph(G, chimera_layout(G), **kwargs)
-
+    layout = chimera_layout(G, plot_kwargs=kwargs)
+    draw_qubit_graph(G, layout, **kwargs)
 
 def draw_chimera_embedding(G, *args, **kwargs):
     """Draws an embedding onto the chimera graph G, according to layout.
@@ -274,13 +319,22 @@ def draw_chimera_embedding(G, *args, **kwargs):
         the same vertices in G), and the drawing will display these overlaps as
         concentric circles.
 
+    line_plot : boolean (optional, default False)
+        If ``line_plot`` is True, then qubits are drawn as line segments, and
+        edges are drawn either as line segments between qubits, or as circles
+        where two qubits overlap.  In this drawing style, the interpretation of
+        the ``width`` and ``node_size`` parameters (provided in ``kwargs``)
+        determine the area of the circles and line widths respectively.  See
+        :func:`dwave_networkx.qubit_layout.draw_lineplot` for more information.
+
     kwargs : optional keywords
        See networkx.draw_networkx() for a description of optional keywords,
        with the exception of the `pos` parameter which is not used by this
        function. If `linear_biases` or `quadratic_biases` are provided,
        any provided `node_color` or `edge_color` arguments are ignored.
     """
-    draw_embedding(G, chimera_layout(G), *args, **kwargs)
+    layout = chimera_layout(G, plot_kwargs=kwargs)
+    draw_embedding(G, layout, *args, **kwargs)
 
 
 def draw_chimera_yield(G, **kwargs):
@@ -296,16 +350,27 @@ def draw_chimera_yield(G, **kwargs):
         If unused_color is None, these nodes and edges will not be shown at all.
 
     fault_color : tuple or color string (optional, default (1.0,0.0,0.0,1.0))
-        A color to represent nodes absent from the graph G. Colors should be
+        A color to represent nodes absent from the graph G.
+
+    incident_fault_color : tuple or color string (optional, default (1.0,0.8,0.8,1.0))
+        A color to represent edges incident to faulty nodes.  Colors should be
         length-4 tuples of floats between 0 and 1 inclusive.
 
-    fault_shape : string, optional (default='x')
+    fault_shape : string, optional (default='o')
         The shape of the fault nodes. Specification is as matplotlib.scatter
         marker, one of 'so^>v<dph8'.
 
     fault_style : string, optional (default='dashed')
         Edge fault line style (solid|dashed|dotted|dashdot)
 
+    line_plot : boolean (optional, default False)
+        If ``line_plot`` is True, then qubits are drawn as line segments, and
+        edges are drawn either as line segments between qubits, or as circles
+        where two qubits overlap.  In this drawing style, the interpretation of
+        the ``width`` and ``node_size`` parameters (provided in ``kwargs``)
+        determine the area of the circles and line widths respectively.  See
+        :func:`dwave_networkx.qubit_layout.draw_lineplot` for more information.
+
     kwargs : optional keywords
        See networkx.draw_networkx() for a description of optional keywords,
        with the exception of the `pos` parameter which is not used by this
@@ -323,5 +388,5 @@ def draw_chimera_yield(G, **kwargs):
         tile, and label attributes to be able to identify faulty qubits.")
 
     perfect_graph = chimera_graph(m,n,t, coordinates=coordinates)
-
-    draw_yield(G, chimera_layout(perfect_graph), perfect_graph, **kwargs)
+    layout = chimera_layout(perfect_graph, plot_kwargs=kwargs)
+    draw_yield(G, layout, perfect_graph, **kwargs)
diff --git a/dwave_networkx/drawing/pegasus_layout.py b/dwave_networkx/drawing/pegasus_layout.py
index e540b4d4..a2825e48 100644
--- a/dwave_networkx/drawing/pegasus_layout.py
+++ b/dwave_networkx/drawing/pegasus_layout.py
@@ -19,7 +19,7 @@
 import networkx as nx
 from networkx import draw
 
-from dwave_networkx.drawing.qubit_layout import draw_qubit_graph, draw_embedding, draw_yield
+from dwave_networkx.drawing.qubit_layout import draw_qubit_graph, draw_embedding, draw_yield, normalize_size_and_aspect, draw_lineplot
 from dwave_networkx.generators.pegasus import pegasus_graph, pegasus_coordinates
 from dwave_networkx.drawing.chimera_layout import chimera_node_placer_2d
 
@@ -31,7 +31,7 @@
            ]
 
 
-def pegasus_layout(G, scale=1., center=None, dim=2, crosses=False):
+def pegasus_layout(G, scale=1., center=None, dim=2, crosses=False, plot_kwargs=None):
     """Positions the nodes of graph G in a Pegasus topology.
 
     `NumPy <https://scipy.org>`_ is required for this function.
@@ -58,6 +58,13 @@ def pegasus_layout(G, scale=1., center=None, dim=2, crosses=False):
         rather than L configuration. Ignored if G is defined with
         ``nice_coordinates=True``.
 
+    plot_kwargs : None or dict (default None)
+        A dict of keyword arguments to be used in a plotting function (see
+        :func:`networkx.drawing.nx_pylab.draw` and :func:`draw_lineplot`), to scale node and edge
+        sizes appropriately to the graph `G`.  Optional keys in ``plot_kwargs``
+        are set to default values by the :func:`normalize_size_and_aspect`
+        function.  Do nothing if ``plot_kwargs`` is None.
+
     Returns
     -------
     pos : dict
@@ -75,28 +82,30 @@ def pegasus_layout(G, scale=1., center=None, dim=2, crosses=False):
     if not isinstance(G, nx.Graph) or G.graph.get("family") != "pegasus":
         raise ValueError("G must be generated by dwave_networkx.pegasus_graph")
 
-    if G.graph.get('labels') == 'nice':
-        m = 3*(G.graph['rows']-1)
-        c_coords = chimera_node_placer_2d(m, m, 4, scale=scale, center=center, dim=dim)
-        def xy_coords(t, y, x, u, k):
-            return c_coords(3*y+2-t, 3*x+t, u, k)
+    labels = G.graph.get('labels')
+    if labels == 'coordinate':    
+        crosses = True
+    
+    xy_coords = pegasus_node_placer_2d(G, scale, center, dim, crosses, plot_kwargs)
+
+    if labels == 'coordinate':
         pos = {v: xy_coords(*v) for v in G.nodes()}
+    elif G.graph['data']:
+        pos = {v: xy_coords(*dat['pegasus_index']) for v, dat in G.nodes(data=True)}
     else:
-        xy_coords = pegasus_node_placer_2d(G, scale, center, dim, crosses=crosses)
-
-        if G.graph.get('labels') == 'coordinate':
-            pos = {v: xy_coords(*v) for v in G.nodes()}
-        elif G.graph.get('data'):
-            pos = {v: xy_coords(*dat['pegasus_index']) for v, dat in G.nodes(data=True)}
-        else:
-            m = G.graph.get('rows')
-            coord = pegasus_coordinates(m)
+        m = G.graph['rows']
+        coord = pegasus_coordinates(m)
+        if labels == 'int':
             pos = {v: xy_coords(*coord.linear_to_pegasus(v)) for v in G.nodes()}
+        elif labels == 'nice':
+            pos = {v: xy_coords(*coord.nice_to_pegasus(v)) for v in G.nodes()}
+        else:
+            raise ValueError(f"Pegasus labeling {labels} not recognized")
 
     return pos
 
 
-def pegasus_node_placer_2d(G, scale=1., center=None, dim=2, crosses=False):
+def pegasus_node_placer_2d(G, scale=1., center=None, dim=2, crosses=False, plot_kwargs=None):
     """Generates a function to convert Pegasus indices to plottable coordinates.
 
     Parameters
@@ -120,6 +129,13 @@ def pegasus_node_placer_2d(G, scale=1., center=None, dim=2, crosses=False):
         If True, :math:`K_{4,4}` subgraphs are shown in a cross
         rather than L configuration.
 
+    plot_kwargs : None or dict (default None)
+        A dict of keyword arguments to be used in a plotting function (see
+        :func:`networkx.drawing.nx_pylab.draw` and :func:`draw_lineplot`), to scale node and edge
+        sizes appropriately to the graph `G`.  Optional keys in ``plot_kwargs``
+        are set to default values by the :func:`normalize_size_and_aspect`
+        function.  Do nothing if ``plot_kwargs`` is None.
+
     Returns
     -------
     xy_coords : function
@@ -129,50 +145,72 @@ def pegasus_node_placer_2d(G, scale=1., center=None, dim=2, crosses=False):
     """
     import numpy as np
 
-    m = G.graph.get('rows')
-    h_offsets = G.graph.get("horizontal_offsets")
-    v_offsets = G.graph.get("vertical_offsets")
-    tile_width = G.graph.get("tile")
+    line_plot = False if plot_kwargs is None else plot_kwargs.get('line_plot')
+
+    if line_plot:
+        crosses = False
+
+    m = G.graph['rows']
+    h_offsets = G.graph["horizontal_offsets"]
+    v_offsets = G.graph["vertical_offsets"]
+    tile_width = G.graph["tile"]
+    odd_k_wobble = .05
     tile_center = tile_width / 2 - .5
+    cross_shift = 2 if crosses else 0
 
     # want the enter plot to fill in [0, 1] when scale=1
-    scale /= m * tile_width
+    fabric_scale = m*tile_width - 2*odd_k_wobble - 1
+    scale /= fabric_scale
+
+    if plot_kwargs is not None:
+        normalize_size_and_aspect(fabric_scale, 150, plot_kwargs)
 
     if center is None:
         center = np.zeros(dim)
     else:
         center = np.asarray(center)
 
-    paddims = dim - 2
-    if paddims < 0:
+    center[0] -= (cross_shift + odd_k_wobble)*scale
+    center[1] -= (cross_shift - odd_k_wobble)*scale
+
+    if dim < 0:
         raise ValueError("layout must have at least two dimensions")
 
+    # pad the dimensions beyond the second with zeros
+    paddims = np.zeros(dim - 2)
+
     if len(center) != dim:
         raise ValueError("length of center coordinates must match dimension of layout")
 
-    if crosses:
-        # adjustment for crosses
-        cross_shift = 2.
-    else:
-        cross_shift = 0.
-
     def _xy_coords(u, w, k, z):
         # orientation, major perpendicular offset, minor perpendicular offset, parallel offset
 
         if k % 2:
-            p = -.1
+            p = -odd_k_wobble
         else:
-            p = .1
+            p = odd_k_wobble
 
         if u:
-            xy = np.array([z*tile_width+h_offsets[k] + tile_center, -tile_width*w-k-p+cross_shift])
+            xy = np.array([z*tile_width+h_offsets[k] + tile_center, -tile_width*w-k-p+cross_shift], dtype='float')
         else:
-            xy = np.array([tile_width*w+k+p+cross_shift, -z*tile_width-v_offsets[k]-tile_center])
+            xy = np.array([tile_width*w+k+p+cross_shift, -z*tile_width-v_offsets[k]-tile_center], dtype='float')
 
         # convention for Pegasus-lattice pictures is to invert the y-axis
-        return np.hstack((xy * scale, np.zeros(paddims))) + center
-
-    return _xy_coords
+        return np.hstack((xy * scale, paddims)) + center
+
+
+    if line_plot:
+        qubit_dx = np.hstack(([5.75, 0], paddims)) * scale
+        qubit_dy = np.hstack(([0, 5.75], paddims)) * scale
+        def _line_coords(u, w, k, z):
+            xy = _xy_coords(u, w, k, z)
+            if u:
+                return np.vstack((xy - qubit_dx, xy + qubit_dx))
+            else:
+                return np.vstack((xy - qubit_dy, xy + qubit_dy))
+        return _line_coords
+    else:
+        return _xy_coords
 
 
 def draw_pegasus(G, crosses=False, **kwargs):
@@ -199,7 +237,15 @@ def draw_pegasus(G, crosses=False, **kwargs):
     crosses: boolean (optional, default False)
         If True, :math:`K_{4,4}` subgraphs are shown in a cross
         rather than L configuration. Ignored if G is defined with
-        ``nice_coordinates=True``.
+        ``nice_coordinates=True`` or ``line_plot=True``.
+
+    line_plot : boolean (optional, default False)
+        If ``line_plot`` is True, then qubits are drawn as line segments, and
+        edges are drawn either as line segments between qubits, or as circles
+        where two qubits overlap.  In this drawing style, the interpretation of
+        the ``width`` and ``node_size`` parameters (provided in ``kwargs``)
+        determine the area of the circles and line widths respectively.  See
+        :func:`dwave_networkx.qubit_layout.draw_lineplot` for more information.
 
     kwargs : optional keywords
        See networkx.draw_networkx() for a description of optional keywords,
@@ -219,11 +265,10 @@ def draw_pegasus(G, crosses=False, **kwargs):
     >>> plt.show()    # doctest: +SKIP
 
     """
+    layout = pegasus_layout(G, plot_kwargs=kwargs)
+    draw_qubit_graph(G, layout, **kwargs)
 
-    draw_qubit_graph(G, pegasus_layout(G, crosses=crosses), **kwargs)
-
-
-def draw_pegasus_embedding(G, *args, **kwargs):
+def draw_pegasus_embedding(G, *args, crosses=False, **kwargs):
     """Draws an embedding onto Pegasus graph G.
 
     Parameters
@@ -270,16 +315,24 @@ def draw_pegasus_embedding(G, *args, **kwargs):
         If True, chains in ``emb`` may overlap (contain the same vertices
         in G), and these overlaps are displayed as concentric circles.
 
+    line_plot : boolean (optional, default False)
+        If ``line_plot`` is True, then qubits are drawn as line segments, and
+        edges are drawn either as line segments between qubits, or as circles
+        where two qubits overlap.  In this drawing style, the interpretation of
+        the ``width`` and ``node_size`` parameters (provided in ``kwargs``)
+        determine the area of the circles and line widths respectively.  See
+        :func:`dwave_networkx.qubit_layout.draw_lineplot` for more information.
+
     kwargs : optional keywords
        See networkx.draw_networkx() for a description of optional keywords,
        with the exception of the ``pos`` parameter, which is not used by this
        function. If ``linear_biases`` or ``quadratic_biases`` are provided,
        any provided ``node_color`` or ``edge_color`` arguments are ignored.
     """
-    crosses = kwargs.pop("crosses", False)
-    draw_embedding(G, pegasus_layout(G, crosses=crosses), *args, **kwargs)
+    layout = pegasus_layout(G, crosses=crosses, plot_kwargs=kwargs)
+    draw_embedding(G, layout, *args, **kwargs)
 
-def draw_pegasus_yield(G, **kwargs):
+def draw_pegasus_yield(G, crosses=False, **kwargs):
     """Draws the given graph G with highlighted faults, according to layout.
 
     Parameters
@@ -292,16 +345,32 @@ def draw_pegasus_yield(G, **kwargs):
         If unused_color is None, these nodes and edges will not be shown at all.
 
     fault_color : tuple or color string (optional, default (1.0,0.0,0.0,1.0))
-        A color to represent nodes absent from the graph G. Colors should be
+        A color to represent nodes absent from the graph G.
+
+    incident_fault_color : tuple or color string (optional, default (1.0,0.8,0.8,1.0))
+        A color to represent edges incident to faulty nodes.  Colors should be
         length-4 tuples of floats between 0 and 1 inclusive.
 
-    fault_shape : string, optional (default='x')
+    fault_shape : string, optional (default='o')
         The shape of the fault nodes. Specification is as matplotlib.scatter
         marker, one of 'so^>v<dph8'.
 
     fault_style : string, optional (default='dashed')
         Edge fault line style (solid|dashed|dotted|dashdot)
 
+    crosses: boolean (optional, default False)
+        If True, :math:`K_{4,4}` subgraphs are shown in a cross
+        rather than L configuration. Ignored if G is defined with
+        ``nice_coordinates=True`` or ``line_plot=True``.
+
+    line_plot : boolean (optional, default False)
+        If ``line_plot`` is True, then qubits are drawn as line segments, and
+        edges are drawn either as line segments between qubits, or as circles
+        where two qubits overlap.  In this drawing style, the interpretation of
+        the ``width`` and ``node_size`` parameters (provided in ``kwargs``)
+        determine the area of the circles and line widths respectively.  See
+        :func:`dwave_networkx.qubit_layout.draw_lineplot` for more information.
+
     kwargs : optional keywords
        See networkx.draw_networkx() for a description of optional keywords,
        with the exception of the `pos` parameter which is not used by this
@@ -321,5 +390,5 @@ def draw_pegasus_yield(G, **kwargs):
 
 
     perfect_graph = pegasus_graph(m, offset_lists=offset_lists, coordinates=coordinates, nice_coordinates=nice)
-
-    draw_yield(G, pegasus_layout(perfect_graph), perfect_graph, **kwargs)
+    layout = pegasus_layout(perfect_graph, crosses=crosses, plot_kwargs=kwargs)
+    draw_yield(G, layout, perfect_graph, **kwargs)
diff --git a/dwave_networkx/drawing/qubit_layout.py b/dwave_networkx/drawing/qubit_layout.py
index 7dffb996..be9ea4b7 100644
--- a/dwave_networkx/drawing/qubit_layout.py
+++ b/dwave_networkx/drawing/qubit_layout.py
@@ -23,13 +23,16 @@
 from networkx import draw
 
 from dwave_networkx.drawing.distinguishable_colors import distinguishable_color_map
+from itertools import repeat, chain
 
-__all__ = ['draw_qubit_graph']
+from numbers import Number
+
+__all__ = ['draw_qubit_graph', 'draw_embedding', 'draw_yield', 'normalize_size_and_aspect', 'draw_lineplot']
 
 
 def draw_qubit_graph(G, layout, linear_biases={}, quadratic_biases={},
                      nodelist=None, edgelist=None, cmap=None, edge_cmap=None, vmin=None, vmax=None,
-                     edge_vmin=None, edge_vmax=None, midpoint=None,
+                     edge_vmin=None, edge_vmax=None, midpoint=None, line_plot=False,
                      **kwargs):
     """Draws graph G according to layout.
 
@@ -60,6 +63,16 @@ def draw_qubit_graph(G, layout, linear_biases={}, quadratic_biases={},
         be. If not provided, the colormap will default to the middle of
         min/max values provided.
 
+    line_plot : boolean (optional, default False)
+        If line_plot is True, then qubits are drawn as line segments, and edges
+        are drawn either as line segments between qubits, or as circles where
+        two qubits overlap.  In this drawing style, the interpretation the width
+        and node_size parameters (provided in kwargs) determines the area of the
+        circles, and line widths, respectively.  Qubit line segments are given
+        twice the width of edges.  Layout should be a dict of the form
+        {node: ((x0, y0), (y0, x0)), ...} -- instead of coordinates, the nodes
+        are associated with endpoints of n-dimensional line segments.
+
     kwargs : optional keywords
        See networkx.draw_networkx() for a description of optional keywords,
        with the exception of the `pos` parameter which is not used by this
@@ -178,15 +191,21 @@ def node_color(v):
         if ax is None:
             ax = fig.add_axes([0.01, 0.01, 0.98, 0.98])
 
-    draw(G, layout, ax=ax, nodelist=nodelist, edgelist=edgelist,
-         cmap=cmap, edge_cmap=edge_cmap, vmin=vmin, vmax=vmax, edge_vmin=edge_vmin,
-         edge_vmax=edge_vmax,
-         **kwargs)
+    if line_plot:
+        draw_lineplot(G, layout, ax=ax, nodelist=nodelist, edgelist=edgelist,
+             cmap=cmap, edge_cmap=edge_cmap, vmin=vmin, vmax=vmax, edge_vmin=edge_vmin,
+             edge_vmax=edge_vmax,
+             **kwargs)
+    else:
+        draw(G, layout, ax=ax, nodelist=nodelist, edgelist=edgelist,
+             cmap=cmap, edge_cmap=edge_cmap, vmin=vmin, vmax=vmax, edge_vmin=edge_vmin,
+             edge_vmax=edge_vmax,
+             **kwargs)
 
 
 def draw_embedding(G, layout, emb, embedded_graph=None, interaction_edges=None,
                    chain_color=None, unused_color=(0.9,0.9,0.9,1.0), cmap=None,
-                   show_labels=False, overlapped_embedding=False, **kwargs):
+                   show_labels=False, overlapped_embedding=False, line_plot=False, **kwargs):
     """Draws an embedding onto the graph G, according to layout.
 
     If interaction_edges is not None, then only display the couplers in that
@@ -240,6 +259,16 @@ def draw_embedding(G, layout, emb, embedded_graph=None, interaction_edges=None,
         the same vertices in G), and the drawing will display these overlaps as
         concentric circles.
 
+    line_plot : boolean (optional, default False)
+        If line_plot is True, then qubits are drawn as line segments, and edges
+        are drawn either as line segments between qubits, or as circles where
+        two qubits overlap.  In this drawing style, the interpretation the width
+        and node_size parameters (provided in kwargs) determines the area of the
+        circles, and line widths, respectively.  Qubit line segments are given
+        twice the width of edges.  Layout should be a dict of the form
+        {node: ((x0, y0), (y0, x0)), ...} -- instead of coordinates, the nodes
+        are associated with endpoints of n-dimensional line segments.
+
     kwargs : optional keywords
        See networkx.draw_networkx() for a description of optional keywords,
        with the exception of the `pos` parameter which is not used by this
@@ -252,6 +281,12 @@ def draw_embedding(G, layout, emb, embedded_graph=None, interaction_edges=None,
     except ImportError:
         raise ImportError("Matplotlib and numpy required for draw_chimera()")
 
+    if line_plot and show_labels:
+        raise NotImplementedError("line_plot style drawings do not currently support node labels")
+    
+    if line_plot and overlapped_embedding:
+        raise NotImplementedError("line_plot style drawings do not currently support overlapped embeddings")
+
     if nx.utils.is_string_like(unused_color):
         from matplotlib.colors import colorConverter
         alpha = kwargs.get('alpha', 1.0)
@@ -371,15 +406,25 @@ def show(p, q, u, v): return True
                 c = emb[v]
                 labels[list(c)[0]] = str(v)
 
-    # draw the background (unused) graph first
-    if unused_color is not None:
-        draw(G, layout, nodelist=nodelist, edgelist=background_edgelist,
-             node_color=node_color, edge_color=background_edge_color,
-             **kwargs)
+    if line_plot:
+        if unused_color is not None:
+            draw_lineplot(G, layout, nodelist=nodelist, edgelist=background_edgelist,
+                 node_color=node_color, edge_color=background_edge_color,
+                 **kwargs)
 
-    draw(G, layout, nodelist=nodelist, edgelist=edgelist,
-         node_color=node_color, edge_color=edge_color, labels=labels,
-         **kwargs)
+        draw_lineplot(G, layout, nodelist=nodelist, edgelist=edgelist,
+             node_color=node_color, edge_color=edge_color, z_offset = 10,
+             **kwargs)    
+    else:
+        # draw the background (unused) graph first
+        if unused_color is not None:
+            draw(G, layout, nodelist=nodelist, edgelist=background_edgelist,
+                 node_color=node_color, edge_color=background_edge_color,
+                 **kwargs)
+
+        draw(G, layout, nodelist=nodelist, edgelist=edgelist,
+             node_color=node_color, edge_color=edge_color, labels=labels,
+             **kwargs)
 
 
 def compute_bags(C, emb):
@@ -424,9 +469,9 @@ def unoverlapped_embedding(G, emb, interaction_edges):
 
 
 def draw_yield(G, layout, perfect_graph, unused_color=(0.9,0.9,0.9,1.0),
-                    fault_color=(1.0,0.0,0.0,1.0), fault_shape='x',
-                    fault_style='dashed', **kwargs):
-
+               fault_color=(1.0,0.0,0.0,1.0), fault_shape='o',
+               fault_style='dashed', incident_fault_color=(1.0,0.8,0.8,1.0),
+               line_plot = False, **kwargs):
     """Draws the given graph G with highlighted faults, according to layout.
 
     Parameters
@@ -442,22 +487,35 @@ def draw_yield(G, layout, perfect_graph, unused_color=(0.9,0.9,0.9,1.0),
     perfect_graph : NetworkX graph
         The graph to be drawn with highlighted faults
 
-
     unused_color : tuple or color string (optional, default (0.9,0.9,0.9,1.0))
         The color to use for nodes and edges of G which are not faults.
         If unused_color is None, these nodes and edges will not be shown at all.
 
     fault_color : tuple or color string (optional, default (1.0,0.0,0.0,1.0))
-        A color to represent nodes absent from the graph G. Colors should be
+        A color to represent nodes absent from the graph G, and edges absent
+        from the graph G which are not incident to faulty nodes. 
+
+    incident_fault_color : tuple or color string (optional, default (1.0,0.8,0.8,1.0))
+        A color to represent edges incident to faulty nodes.  Colors should be
         length-4 tuples of floats between 0 and 1 inclusive.
 
-    fault_shape : string, optional (default='x')
+    fault_shape : string, optional (default='o')
         The shape of the fault nodes. Specification is as matplotlib.scatter
         marker, one of 'so^>v<dph8'.
 
     fault_style : string, optional (default='dashed')
         Edge fault line style (solid|dashed|dotted,dashdot)
 
+    line_plot : boolean (optional, default False)
+        If line_plot is True, then qubits are drawn as line segments, and edges
+        are drawn either as line segments between qubits, or as circles where
+        two qubits overlap.  In this drawing style, the interpretation the width
+        and node_size parameters (provided in kwargs) determines the area of the
+        circles, and line widths, respectively.  Qubit line segments are given
+        twice the width of edges.  Layout should be a dict of the form
+        {node: ((x0, y0), (y0, x0)), ...} -- instead of coordinates, the nodes
+        are associated with endpoints of n-dimensional line segments.
+
     kwargs : optional keywords
        See networkx.draw_networkx() for a description of optional keywords,
        with the exception of the `pos` parameter which is not used by this
@@ -468,34 +526,270 @@ def draw_yield(G, layout, perfect_graph, unused_color=(0.9,0.9,0.9,1.0),
         import matplotlib.pyplot as plt
         import matplotlib as mpl
     except ImportError:
-        raise ImportError("Matplotlib and numpy required for draw_chimera()")
+        raise ImportError("Matplotlib required for draw_yield()")
 
+    edgeset = lambda E: set(map(lambda e: tuple(sorted(e)), E))
     nodelist = G.nodes()
     edgelist = G.edges()
+    
     faults_nodelist = perfect_graph.nodes() - nodelist
-    faults_edgelist = perfect_graph.edges() - edgelist
+    incident_edgelist = edgeset(perfect_graph.edges) - edgeset(perfect_graph.subgraph(nodelist).edges)
+    faults_edgelist = edgeset(perfect_graph.subgraph(nodelist).edges) - edgeset(G.edges)
+
+    if line_plot:
+        if unused_color is not None:
+            node_color = [fault_color if v in faults_nodelist else unused_color for v in perfect_graph]
+            long_edgelist = list(edgeset(perfect_graph.edges) - incident_edgelist - faults_edgelist)
+        else:
+            node_color = []
+            long_edgelist = []
+        edge_color = [unused_color]*len(long_edgelist)
+        long_edgelist.extend(incident_edgelist)
+        edge_color.extend([incident_fault_color]*len(incident_edgelist))
+        long_edgelist.extend(faults_edgelist)
+        edge_color.extend([fault_color]*len(faults_edgelist))
+        draw_lineplot(perfect_graph, layout, edgelist=long_edgelist, node_color=node_color, edge_color=edge_color, **kwargs)
+    else:
+        faults_node_color = [fault_color for v in faults_nodelist]
+        faults_edge_color = [fault_color for e in faults_edgelist]
+        incident_edge_color = [incident_fault_color for e in incident_edgelist]
+
+        # Draw edges first, in the order (unused, incident, faults)
+        if unused_color is not None:
+            unused_edge_color = [unused_color for e in G.edges()]
+            nx.draw_networkx_edges(G, layout, edge_color=unused_edge_color, **kwargs)
+        nx.draw_networkx_edges(perfect_graph, layout, incident_edgelist, style=fault_style, edge_color=incident_edge_color, **kwargs)
+        nx.draw_networkx_edges(perfect_graph, layout, faults_edgelist, style=fault_style, edge_color=faults_edge_color, **kwargs)
+
+        # Draw nodes second, in the order (unused, faults)
+        if unused_color is not None:
+            unused_node_color = [unused_color for e in G]
+            nx.draw_networkx_nodes(G, layout, node_color = unused_node_color, **kwargs)
+        nx.draw_networkx_nodes(perfect_graph, layout, faults_nodelist, node_shape=fault_shape, node_color=faults_node_color, **kwargs)
+
+
+def normalize_size_and_aspect(scale, node_scale, kwargs):
+    """Sets default values for the "ax", "node_size" and "width" keys.
+    
+    If the `"ax"` is not set, then we create an axis from the current
+    `matplotlib` figure (:func:`matplotlib.pyplot.gcf()`).  Then, the the axis
+    (either the one we created, or the pre-existing one) is set to have an
+    aspect ratio of 1 and the drawing of axes is turned off.
+    
+    Then, if `"node_size"` and `"width"` are not set, we compute default values
+    for them based on the scale of the current figure and the scale parameters
+    as appropriate.
+    
+    Note, if `kwargs["line_plot"]` is True, then the interpretation of the 
+    `"width"` and `"node_size"` parameters determine the area of edge-circles
+    and line widths (used for both nodes and edges) respectively.  See 
+    :func:`dwave_networkx.qubit_layout.draw_lineplot` for more information.
+
+    Parameters
+    ----------
+    scale : float
+        A geometric size of a figure to be drawn.  This is roughly the number
+        of qubits in any given row or column of the graph.
+        
+    node_scale : float
+        A magic number used to scale node circles -- ignored and replaced with
+        the number 50 when `kwargs["line_plot"]` is True.
+    
+    kwargs : dict
+        A dictionary to populate with default values.    
+    """
+    ax = kwargs.get('ax')
+    if ax is None:
+        try:
+            import matplotlib.pyplot as plt
+        except ImportError:
+            raise ImportError("Matplotlib required for graph drawing")
+        cf = plt.gcf()
+    else:
+        cf = ax.get_figure()
+    cf.set_facecolor("w")
+    if ax is None:
+        if cf.axes:
+            ax = cf.gca()
+        else:
+            ax = cf.add_axes((0, 0, 1, 1))
+    kwargs['ax'] = ax
+    ax.set_aspect(1)
+    fig_scale = min(cf.get_figheight(), cf.get_figwidth())
+    ax.set_axis_off()
+
+    if kwargs.get('node_size') is None:
+        if kwargs.get("line_plot"):
+            kwargs['node_size'] = 50*(fig_scale/scale)**2
+        else:
+            kwargs['node_size'] = node_scale*(fig_scale/scale)**2
 
-    # To avoid matplotlib.pyplot.scatter warnings for single tuples, create
-    # lists of colors from given colors.
-    faults_node_color = [fault_color for v in faults_nodelist]
-    faults_edge_color = [fault_color for v in faults_edgelist]
+    if kwargs.get('width') is None:
+        if kwargs.get("line_plot"):
+            kwargs['width'] = 5*(fig_scale / scale)
+        else:
+            kwargs['width'] = 2*(fig_scale / scale)
+
+
+def draw_lineplot(G, layout, *, ax, node_size, width, nodelist=None,
+                  edgelist=None, node_color='blue', edge_color='black',
+                  cmap=None, vmin=None, vmax=None, edge_cmap=None,
+                  edge_vmin=None, edge_vmax=None, z_offset=0):
+    """Draws the graph G with line segments representing nodes.
+
+    This function is meant to be a drop-in replacement for :func:`networkx.drawing.nx_pylab.draw`
+    where nodes are associated with line segments (specified as 2x2 matrices
+    [[x0, y0], [x1, y1]]).  This function makes significant assumptions about
+    the edges of the graph G, that hold when G is a Chimera, Pegasus, or Zephyr
+    graph and the line segments are provided by :func:`chimera_layout`,
+    :func:`pegasus_layout` and :func:`zephyr_layout` respectively.  These graphs
+    have three classes of edges:
+
+        * internal edges between qubits whose line segments are perpendicular
+            and intersect at a point, drawn as a circle located at the point of
+            intersection,
+        * external edges between qubits whose line segments are colinear, drawn
+            as a line segment between the nearest endpoints, and
+        * odd edges between parallel qubits whose line segments are parallel and
+          overlap in a perpendicular projection, drawn as a line segment between
+          the midpoints of the respective perpendicular projections.
 
-    # Draw faults with different style and shape
-    draw(perfect_graph, layout, nodelist=faults_nodelist, edgelist=faults_edgelist,
-        node_color=faults_node_color, edge_color=faults_edge_color,
-        style=fault_style, node_shape=fault_shape,
-        **kwargs )
+    Parameters
+    ----------
 
-    # Draw rest of graph
-    if unused_color is not None:
-        if nodelist is None:
-            nodelist = G.nodes() - faults_nodelist
-        if edgelist is None:
-            edgelist = G.edges() - faults_edgelist
+    G : networkx.Graph
+        A graph constructed by :func:`chimera_layout`, :func:`pegasus_layout`,
+        or :func:`zephyr_layout`.
 
-        unused_node_color = [unused_color for v in nodelist]
-        unused_edge_color = [unused_color for v in edgelist]
+    layout : dict
+        A dictionary with nodes as keys and 2x2 matrices [[x0, y0], [x1, y1]]
+        representing the line segments of nodes.
+
+    ax : matplotlib.Axis
+        The matplotlib Axis object to draw the graph on.
+
+    node_size : float
+        The size (in area) of the circles used to depict internal edges.
+
+    width : float
+        The width of line segments associated with edges, and half the width of
+        line segments associated with nodes.
+
+    nodelist : iterable or None (default=None)
+        The set of nodes to draw.  If None, all nodes from G are drawn.
+
+    edgelist : iterable or None (default=None)
+        The set of edges to draw.  If both nodelist and ``edgelist`` are None,
+        all edges of G are drawn.  If ``edgelist`` is None, all edges from the
+        subgraph ``G.subgraph(nodelist)`` are drawn.
+
+    node_color : iterable or string (default='blue')
+        The sequence of colors to use in drawing nodes of G.  If node_color is
+        not a string, the colors are taken in the same order as nodelist, and
+        each color is either a float, a 3-tuple or 4-tuple of floats.
+
+    edge_color : iterable or string (default='black')
+        The sequence of colors to use in drawing edges of G.  If edge_color is
+        not a string, the colors are taken in the same order as ``edgelist``,
+        and each color is either a float, a 3-tuple or 4-tuple of floats.
+
+    cmap : string or matplotlib.ColorMap or None (default=None)
+        A colormap to color nodes with.  Presumes that node_color is a sequence
+        of floats.
+
+    vmin : float or None (default=None)
+        Minimum value to use to use when normalizing node colors through
+        ``cmap``.
+
+    vmax : float or None (default=None)
+        Maximum value to use to use when normalizing node colors through
+        ``cmap``.
+
+    edge_cmap : string or matplotlib.ColorMap or None (default=None)
+        A colormap to color edges with.  Presumes that edge_color is a sequence
+        of floats.
+
+    edge_vmin : float or None (default=None)
+        Minimum value to use to use when normalizing edge colors through
+        ``edge_cmap``.
+
+    edge_vmax : float or None (default=None)
+        Maximum value to use to use when normalizing edge colors through
+        ``edge_cmap``.
+    
+    z_offset : int (default=0)
+        An offset to the "zorder: that various elements are drawn in.  Edge
+        lines are drawn with `zorder=z_offset`; horizontal node lines are drawn
+        with `zorder=zoffset+1`; vertical node lines are drawn with
+        `zorder=zoffset+2`, and edge circles are drawn with `zorder=zoffset+3`.
+        This parameter can be used to layer line plots over or under each other.
+    """
+    try:
+        from networkx.drawing.nx_pylab import apply_alpha
+        import numpy as np
+        from matplotlib.collections import LineCollection, CircleCollection
+    except ImportError:
+        raise ImportError("Matplotlib and NumPy required for draw_lineplot()")
+
+    if not isinstance(node_size, Number) or not isinstance(width, Number):
+        raise NotImplementedError("Varying node size and edge width per element in line plots is not implemented")
 
-        draw(perfect_graph, layout, nodelist=nodelist, edgelist=edgelist,
-            node_color=unused_node_color, edge_color=unused_edge_color,
-            **kwargs)
+    if edgelist is None:
+        if nodelist is not None:
+            edgelist = G.subgraph(nodelist).edges
+        else:
+            edgelist = G.edges
+    if nodelist is None:
+        nodelist = G
+
+    node_color = apply_alpha(node_color, 1, nodelist, cmap=cmap, vmin=vmin, vmax=vmax)
+    node_lines = np.array([layout[v] for v in nodelist], dtype='float')
+    vertical = np.array([abs(x0-x1) < abs(y0-y1) for (x0, y0), (x1, y1) in node_lines], dtype='bool')
+    if node_color.shape == (1, 4):
+        vcolor = hcolor = node_color
+    else:
+        vcolor = node_color[vertical]
+        hcolor = node_color[~vertical]
+    ax.add_collection(LineCollection(node_lines[~vertical], edgecolor=hcolor, linewidths=width, zorder=1+z_offset, capstyle='round'))
+    ax.add_collection(LineCollection(node_lines[vertical], edgecolor=vcolor, linewidths=width, zorder=2+z_offset, capstyle='round'))
+
+    if edge_color is not None and len(edgelist):
+        vertical = dict(zip(nodelist, map(int, vertical)))
+        as_line = np.full(len(edgelist), False, dtype='bool')
+        edge_data = np.empty((len(edgelist), 2, 2), dtype='float')
+        for i, (u, v) in enumerate(edgelist):
+            u0, u1 = layout[u]
+            v0, v1 = layout[v]
+            orientation = vertical[u]
+            if orientation == vertical[v]:
+                as_line[i] = True
+                if u0[orientation] > v1[orientation]:
+                    # external; v1 < u0
+                    edge_data[i] = v1, u0
+                elif v0[orientation] > u1[orientation]:
+                    # external; u1 < v0
+                    edge_data[i] = u1, v0
+                elif orientation:
+                    # odd, vertical
+                    ymean = (u0[1] + u1[1] + v0[1] + v1[1])/4
+                    edge_data[i] = (u0[0], ymean), (v0[0], ymean)
+                else:
+                    # odd, horizontal
+                    xmean = (u0[0] + u1[0] + v0[0] + v1[0])/4
+                    edge_data[i] = (xmean, u0[1]), (xmean, v0[1])
+            elif orientation:
+                # internal, u is vertical and v is horizontal
+                edge_data[i, 0] = u0[0], v0[1]
+            else:
+                # internal, v is vertical and u is horizontal
+                edge_data[i, 0] = v0[0], u0[1]
+
+        edge_color = apply_alpha(edge_color, 1, edgelist, cmap=edge_cmap, vmin=edge_vmin, vmax=edge_vmax)
+        if edge_color.shape == (1, 4):
+            edge_line_color = edge_spot_color = edge_color
+        else:
+            edge_line_color = edge_color[as_line]
+            edge_spot_color = edge_color[~as_line]
+        ax.add_collection(LineCollection(edge_data[as_line], edgecolor=edge_line_color, linewidths=width/2, zorder=z_offset))
+        ax.scatter(*edge_data[~as_line, 0].T, c=edge_spot_color, zorder=3+z_offset, s=node_size)
+    ax.autoscale_view()
diff --git a/dwave_networkx/drawing/zephyr_layout.py b/dwave_networkx/drawing/zephyr_layout.py
index 7f22d6eb..5262b1b8 100644
--- a/dwave_networkx/drawing/zephyr_layout.py
+++ b/dwave_networkx/drawing/zephyr_layout.py
@@ -19,7 +19,7 @@
 import networkx as nx
 from networkx import draw
 
-from dwave_networkx.drawing.qubit_layout import draw_qubit_graph, draw_embedding, draw_yield
+from dwave_networkx.drawing.qubit_layout import draw_qubit_graph, draw_embedding, draw_yield, normalize_size_and_aspect, draw_lineplot
 from dwave_networkx.generators.zephyr import zephyr_graph, zephyr_coordinates
 
 
@@ -30,7 +30,7 @@
            ]
 
 
-def zephyr_layout(G, scale=1., center=None, dim=2):
+def zephyr_layout(G, scale=1., center=None, dim=2, plot_kwargs=None):
     """Positions the nodes of graph G in a Zephyr topology.
 
     `NumPy <https://scipy.org>`_ is required for this function.
@@ -52,6 +52,13 @@ def zephyr_layout(G, scale=1., center=None, dim=2):
         Number of dimensions. When dim > 2, all extra dimensions are
         set to 0.
 
+    plot_kwargs : None or dict (default None)
+        A dict of keyword arguments to be used in a plotting function (see
+        :func:`networkx.drawing.nx_pylab.draw` and :func:`draw_lineplot`), to scale node and edge
+        sizes appropriately to the graph `G`.  Optional keys in ``plot_kwargs``
+        are set to default values by the :func:`~dwave_networkx.drawing.qubit_layout.normalize_size_and_aspect`
+        function.  Do nothing if ``plot_kwargs`` is None.
+
     Returns
     -------
     pos : dict
@@ -69,22 +76,22 @@ def zephyr_layout(G, scale=1., center=None, dim=2):
     if not isinstance(G, nx.Graph) or G.graph.get("family") != "zephyr":
         raise ValueError("G must be generated by dwave_networkx.zephyr_graph")
 
-    xy_coords = zephyr_node_placer_2d(G, scale, center, dim)
+    xy_coords = zephyr_node_placer_2d(G, scale, center, dim, plot_kwargs)
 
-    if G.graph.get('labels') == 'coordinate':
+    if G.graph['labels'] == 'coordinate':
         pos = {v: xy_coords(*v) for v in G.nodes()}
-    elif G.graph.get('data'):
+    elif G.graph['data']:
         pos = {v: xy_coords(*dat['zephyr_index']) for v, dat in G.nodes(data=True)}
     else:
-        m = G.graph.get('rows')
-        t = G.graph.get('tile')
+        m = G.graph['rows']
+        t = G.graph['tile']
         coord = zephyr_coordinates(m, t)
         pos = {v: xy_coords(*coord.linear_to_zephyr(v)) for v in G.nodes()}
 
     return pos
 
 
-def zephyr_node_placer_2d(G, scale=1., center=None, dim=2):
+def zephyr_node_placer_2d(G, scale=1., center=None, dim=2, plot_kwargs=None):
     """Generates a function to convert Zephyr indices to plottable coordinates.
 
     Parameters
@@ -104,6 +111,13 @@ def zephyr_node_placer_2d(G, scale=1., center=None, dim=2):
         Number of dimensions. When dim > 2, all extra dimensions are
         set to 0.
 
+    plot_kwargs : None or dict (default None)
+        A dict of keyword arguments to be used in a plotting function (see
+        :func:`networkx.drawing.nx_pylab.draw` and :func:`draw_lineplot`), to scale node and edge
+        sizes appropriately to the graph `G`.  Optional keys in ``plot_kwargs``
+        are set to default values by the :func:`~dwave_networkx.drawing.qubit_layout.normalize_size_and_aspect`
+        function.  Do nothing if ``plot_kwargs`` is None.
+
     Returns
     -------
     xy_coords : function
@@ -113,39 +127,54 @@ def zephyr_node_placer_2d(G, scale=1., center=None, dim=2):
     """
     import numpy as np
 
-    m = G.graph.get('rows')
-    tile_width = G.graph.get("tile")
+    line_plot = False if plot_kwargs is None else plot_kwargs.get('line_plot')
 
-    # want the enter plot to fill in [0, 1] when scale=1
-    scale /= m * tile_width
+    m = G.graph['rows']
+    tile_width = 2*G.graph["tile"]
+
+    if dim < 2:
+        raise ValueError("layout must have at least two dimensions")
+
+    paddims = np.zeros(dim - 2)
 
     if center is None:
         center = np.zeros(dim)
     else:
         center = np.asarray(center)
 
-    paddims = dim - 2
-    if paddims < 0:
-        raise ValueError("layout must have at least two dimensions")
-
     if len(center) != dim:
         raise ValueError("length of center coordinates must match dimension of layout")
 
     def _xy_coords(u, w, k, j, z):
         # orientation, major perpendicular offset, secondary perpendicular offset, minor perpendicular offset, parallel offset
-        W = 2*tile_width*w + 2*k + .625*j + .125
-        Z = (2*z+j+1)*2*tile_width - .5
-
+        W = tile_width*w + 2*k + .625*j
+        Z = (2*z+j+1)*tile_width - .6875
         if u:
-            xy = np.array([Z, -W])
+            xy = np.array([Z, -W], dtype='float')
         else:
-            xy = np.array([W, -Z])
-
+            xy = np.array([W, -Z], dtype='float')
 
-        return np.hstack((xy * scale, np.zeros(paddims))) + center
-
-    return _xy_coords
+        return np.hstack((xy * scale, paddims)) + center
 
+    # want the enter plot to fill in [0, 1] when scale=1
+    fabric_scale = max(map(abs, _xy_coords(0, 2*m, G.graph["tile"]-1, 1, m-1)))
+    scale /= fabric_scale
+
+    if plot_kwargs is not None:
+        normalize_size_and_aspect(fabric_scale, 200, plot_kwargs)
+
+    if line_plot:
+        qubit_dx = np.hstack(([tile_width - .25, 0], paddims)) * scale
+        qubit_dy = np.hstack(([0, tile_width - .25], paddims)) * scale
+        def _line_coords(u, w, k, j, z):
+            xy = _xy_coords(u, w, k, j, z)
+            if u:
+                return np.vstack((xy - qubit_dx, xy + qubit_dx))
+            else:
+                return np.vstack((xy - qubit_dy, xy + qubit_dy))
+        return _line_coords
+    else:
+        return _xy_coords
 
 def draw_zephyr(G, **kwargs):
     """Draws graph G in a Zephyr topology.
@@ -168,6 +197,14 @@ def draw_zephyr(G, **kwargs):
         edges in G and biases are numeric. Self-loop
         edges (i.e., :math:`i=j`) are treated as linear biases.
 
+    line_plot : boolean (optional, default False)
+        If ``line_plot`` is True, then qubits are drawn as line segments, and
+        edges are drawn either as line segments between qubits, or as circles
+        where two qubits overlap.  In this drawing style, the interpretation of
+        the ``width`` and ``node_size`` parameters (provided in ``kwargs``)
+        determine the area of the circles and line widths respectively.  See
+        :func:`dwave_networkx.qubit_layout.draw_lineplot` for more information.
+
     kwargs : optional keywords
        See :func:`~networkx.drawing.nx_pylab.draw_networkx` for a description of
        optional keywords, with the exception of the ``pos`` parameter, which is
@@ -187,9 +224,8 @@ def draw_zephyr(G, **kwargs):
     >>> plt.show()    # doctest: +SKIP
 
     """
-
-    draw_qubit_graph(G, zephyr_layout(G), **kwargs)
-
+    layout = zephyr_layout(G, plot_kwargs=kwargs)
+    draw_qubit_graph(G, layout, **kwargs)
 
 def draw_zephyr_embedding(G, *args, **kwargs):
     """Draws an embedding onto Zephyr graph G.
@@ -233,6 +269,14 @@ def draw_zephyr_embedding(G, *args, **kwargs):
         If True, chains in ``emb`` may overlap (contain the same vertices
         in G), and these overlaps are displayed as concentric circles.
 
+    line_plot : boolean (optional, default False)
+        If ``line_plot`` is True, then qubits are drawn as line segments, and
+        edges are drawn either as line segments between qubits, or as circles
+        where two qubits overlap.  In this drawing style, the interpretation of
+        the ``width`` and ``node_size`` parameters (provided in ``kwargs``)
+        determine the area of the circles and line widths respectively.  See
+        :func:`dwave_networkx.qubit_layout.draw_lineplot` for more information.
+
     kwargs : optional keywords
        See :func:`~networkx.drawing.nx_pylab.draw_networkx` for a description of
        optional keywords, with the exception of the ``pos`` parameter, which is
@@ -240,7 +284,8 @@ def draw_zephyr_embedding(G, *args, **kwargs):
        are provided, any provided ``node_color`` or ``edge_color`` arguments are
        ignored.
     """
-    draw_embedding(G, zephyr_layout(G), *args, **kwargs)
+    layout = zephyr_layout(G, plot_kwargs=kwargs)
+    draw_embedding(G, layout, *args, **kwargs)
 
 def draw_zephyr_yield(G, **kwargs):
     """Draws the given graph G with highlighted faults, according to layout.
@@ -255,7 +300,10 @@ def draw_zephyr_yield(G, **kwargs):
         If unused_color is None, these nodes and edges will not be shown at all.
 
     fault_color : tuple or color string (optional, default (1.0,0.0,0.0,1.0))
-        A color to represent nodes absent from the graph G. Colors should be
+        A color to represent nodes absent from the graph G.
+
+    incident_fault_color : tuple or color string (optional, default (1.0,0.5,0.5,1.0))
+        A color to represent edges incident to faulty nodes.  Colors should be
         length-4 tuples of floats between 0 and 1 inclusive.
 
     fault_shape : string, optional (default='x')
@@ -267,6 +315,14 @@ def draw_zephyr_yield(G, **kwargs):
     fault_style : string, optional (default='dashed')
         Edge fault line style (solid|dashed|dotted|dashdot)
 
+    line_plot : boolean (optional, default False)
+        If ``line_plot`` is True, then qubits are drawn as line segments, and
+        edges are drawn either as line segments between qubits, or as circles
+        where two qubits overlap.  In this drawing style, the interpretation of
+        the ``width`` and ``node_size`` parameters (provided in ``kwargs``)
+        determine the area of the circles and line widths respectively.  See
+        :func:`dwave_networkx.qubit_layout.draw_lineplot` for more information.
+
     kwargs : optional keywords
        See :func:`~networkx.drawing.nx_pylab.draw_networkx` for a description of
        optional keywords, with the exception of the ``pos`` parameter, which is
@@ -283,7 +339,6 @@ def draw_zephyr_yield(G, **kwargs):
         raise ValueError("Target zephyr graph needs to have columns, rows, \
         tile, and label attributes to be able to identify faulty qubits.")
 
-
     perfect_graph = zephyr_graph(m, t, coordinates=coordinates)
-
-    draw_yield(G, zephyr_layout(perfect_graph), perfect_graph, **kwargs)
+    layout = zephyr_layout(perfect_graph, plot_kwargs=kwargs)
+    draw_yield(G, layout, perfect_graph, **kwargs)
diff --git a/tests/test_chimera_layout.py b/tests/test_chimera_layout.py
index ef5544cd..4561ad10 100644
--- a/tests/test_chimera_layout.py
+++ b/tests/test_chimera_layout.py
@@ -116,3 +116,15 @@ def test_draw_overlapped_chimera_embedding(self):
         emb = {0: [1, 5], 1: [5, 9, 13], 2: [25, 29], 3: [17, 21]}
         dnx.draw_chimera_embedding(C, emb, overlapped_embedding=True)
         dnx.draw_chimera_embedding(C, emb, overlapped_embedding=True, show_labels=True)
+
+    def test_layout_bounds(self):
+        for C in [dnx.chimera_graph(1, 1, 4), dnx.chimera_graph(2, 2, 2), dnx.chimera_graph(4, 4, 4), dnx.chimera_graph(2, 2, 8)]:
+            pos = dnx.chimera_layout(C)
+            minx = min(x for x, y in pos.values())
+            miny = min(y for x, y in pos.values())
+            maxx = max(x for x, y in pos.values())
+            maxy = max(y for x, y in pos.values())
+            self.assertAlmostEqual(minx, 0)
+            self.assertAlmostEqual(maxx, 1)
+            self.assertAlmostEqual(miny, -1)
+            self.assertAlmostEqual(maxy, 0)
diff --git a/tests/test_pegasus_layout.py b/tests/test_pegasus_layout.py
index c344b91d..e9507db2 100644
--- a/tests/test_pegasus_layout.py
+++ b/tests/test_pegasus_layout.py
@@ -102,3 +102,15 @@ def test_draw_overlapped_chimera_embedding(self):
         emb = {0: [12, 35], 1: [12, 31], 2: [32], 3: [14]}
         dnx.draw_pegasus_embedding(C, emb, overlapped_embedding=True)
         dnx.draw_pegasus_embedding(C, emb, overlapped_embedding=True, show_labels=True)
+
+    def test_layout_bounds(self):
+        for P in [dnx.pegasus_graph(2, fabric_only=False), dnx.pegasus_graph(3, fabric_only=False), dnx.pegasus_graph(4, fabric_only=False)]:
+            pos = dnx.pegasus_layout(P)
+            minx = min(x for x, y in pos.values())
+            miny = min(y for x, y in pos.values())
+            maxx = max(x for x, y in pos.values())
+            maxy = max(y for x, y in pos.values())
+            self.assertAlmostEqual(minx, 0)
+            self.assertAlmostEqual(maxx, 1)
+            self.assertAlmostEqual(miny, -1)
+            self.assertAlmostEqual(maxy, 0)
diff --git a/tests/test_zephyr_layout.py b/tests/test_zephyr_layout.py
index f588800b..e7cbd64b 100644
--- a/tests/test_zephyr_layout.py
+++ b/tests/test_zephyr_layout.py
@@ -109,3 +109,15 @@ def test_draw_overlapped_zephyr_embedding(self):
         emb = {0: [1, 3], 1: [3, 128, 15], 2: [25, 140], 3: [17, 122]}
         dnx.draw_zephyr_embedding(C, emb, overlapped_embedding=True)
         dnx.draw_zephyr_embedding(C, emb, overlapped_embedding=True, show_labels=True)
+
+    def test_layout_bounds(self):
+        for Z in [dnx.zephyr_graph(2), dnx.zephyr_graph(3), dnx.zephyr_graph(4), dnx.zephyr_graph(2, 8)]:
+            pos = dnx.zephyr_layout(Z)
+            minx = min(x for x, y in pos.values())
+            miny = min(y for x, y in pos.values())
+            maxx = max(x for x, y in pos.values())
+            maxy = max(y for x, y in pos.values())
+            self.assertAlmostEqual(minx, 0)
+            self.assertAlmostEqual(maxx, 1)
+            self.assertAlmostEqual(miny, -1)
+            self.assertAlmostEqual(maxy, 0)