### Draw a circuit with custom element placement

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_flow.ipynb

This example demonstrates advanced placement of circuit elements using coordinates and relative positioning. The `at=` argument specifies a starting point, and `to=` specifies an ending point for connections.

```python
import schemdraw
import schemdraw.elements as elm

d = schemdraw.Drawing()
# Start drawing at a specific point
d.config(fontsize=12)
start_point = d.add(elm.Dot)

# Add elements relative to each other or absolute positions
d += elm.Resistor().right().at(start_point)
d += elm.Wire().right(d=2)
d += elm.Capacitor().up(d=1.5)
d += elm.Wire().left(d=2)
d += elm.Resistor().at((0, -3))
d.draw()
d.save('custom_placement_circuit.svg')
```

--------------------------------

### Draw a circuit with different element anchor points for wires

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_flow.ipynb

This example shows how to use different anchor points for wires, such as `start` or `end`. This affects how wires are positioned and connected to other elements. Use the `at=` argument with wire elements.

```python
import schemdraw
import schemdraw.elements as elm

d = schemdraw.Drawing()

# Wire anchored at the start
d += elm.Wire(at='start', xy=(0,0), d=2, label='Start Wire')

# Wire anchored at the end
d += elm.Wire(at='end', xy=(0,-2), d=2, label='End Wire')

d.draw()
d.save('wire_anchor_circuit.svg')
```

--------------------------------

### Draw a circuit with different element anchor points

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_flow.ipynb

This example shows how to use different anchor points for elements, such as `center`, `start`, `end`, `top`, `bottom`, `left`, `right`. This affects how elements are positioned and connected. Use the `at=` argument with an anchor.

```python
import schemdraw
import schemdraw.elements as elm

d = schemdraw.Drawing()

# Anchor at the center
d += elm.Resistor(at='center', xy=(0,0), label='Center')

# Anchor at the start
d += elm.Resistor(at='start', xy=(0,-2), label='Start')

# Anchor at the end
d += elm.Resistor(at='end', xy=(0,-4), label='End')

d.draw()
d.save('element_anchor_points_circuit.svg')
```

--------------------------------

### Using Element Properties for Placement

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_elements2.ipynb

Shows how to use element properties like `start` and `end` for precise placement and connection.

```python
import schemdraw
import schemdraw.elements as elm

d = schemdraw.Drawing()
# Add a wire and store it in a variable
w1 = d.add(elm.Wire('right'))
# Add a resistor starting from the end of the wire
r1 = d.add(elm.Resistor().at(w1.end).label('R7'))
# Add another wire from the end of the resistor
w2 = d.add(elm.Wire('down').at(r1.end))
d.draw()
d.save('element_properties.svg')
```

--------------------------------

### Creating a Simple Schematic with Schemdraw

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_elements.ipynb

A basic example of creating a simple schematic, such as a voltage source connected to a resistor. This serves as a starting point for more complex designs.

```python
import schemdraw
import schemdraw.elements as elm
d = schemdraw.Drawing()
d += elm.SourceV().label('V_in')
d += elm.Resistor().right().label('R_load')
d.draw()
```

--------------------------------

### Customizing Line Styles and Colors

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_intcircuits.ipynb

This example demonstrates how to customize the appearance of lines and components, including line styles, colors, and thicknesses.

```python
import schemdraw
d = schemdraw.Drawing()
d += schemdraw.elements.Resistor(color='blue', style='dashed')
d += schemdraw.elements.Line(color='red', linewidth=2).right()
d.draw()
d.save('custom_styles.svg')
```

--------------------------------

### Draw a circuit with different element anchor points for text

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_flow.ipynb

This example shows how to anchor text labels to specific points on elements, like the start or end of a line. Use the `xy=` argument with element anchors.

```python
import schemdraw
import schemdraw.elements as elm

d = schemdraw.Drawing()

w1 = d.add(elm.Wire('right', d=3))

d.add(elm.Text('Start', xy=w1.start, halign='right'))
d.add(elm.Text('End', xy=w1.end, halign='left'))

d.draw()
d.save('text_anchor_points_circuit.svg')
```

--------------------------------

### Create a Rectifier

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_elements2.ipynb

Instantiate a basic rectifier element. No specific parameters are shown in this example.

```python
elm.Rectifier()
```

--------------------------------

### Import Logic Module

Source: https://github.com/cdelker/schemdraw/blob/master/docs/elements/logic.md

Import the necessary logic module from schemdraw to start drawing logic gates.

```python
from schemdraw import logic
```

--------------------------------

### Draw a circuit with different element anchor points for text labels on wires

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_flow.ipynb

This example shows how to anchor text labels to specific points on wires, like the start or end. This allows for precise annotation of wire segments. Use `xy=` combined with wire anchors.

```python
import schemdraw
import schemdraw.elements as elm

d = schemdraw.Drawing()

w1 = d.add(elm.Wire('right', d=3))

d.add(elm.Text('Wire Start', xy=w1.start, halign='right'))
d.add(elm.Text('Wire End', xy=w1.end, halign='left'))

d.draw()
d.save('wire_text_anchor_circuit.svg')
```

--------------------------------

### Create BitField with SVG backend and many registers

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_timing.ipynb

This example uses the `svg` backend via `schemdraw.use('svg')` and defines a BitField with numerous registers, similar to the previous example, but for SVG output.

```python
schemdraw.use('svg')
logic.BitField.from_json('''
{reg:[
    {name: 'A', bits: 12},
    {name: 'B', bits: 12},
    {name: 'C', bits: 12},
    {name: 'D', bits: 12},
    {name: 'E', bits: 12},
    {name: 'F', bits: 12},
    {name: 'G', bits: 12},
    {name: 'H', bits: 12},
    {name: 'I', bits: 12},
    {name: 'J', bits: 12},
], config: {lanes: 4}
}
'''
)
```

--------------------------------

### Gradient Fill Example

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_styles.ipynb

Demonstrates how to apply gradient fills to elements using the SVG backend. The direction of the gradient can be controlled.

```python
with schemdraw.Drawing():
    flow.Box().gradient_fill('red', 'yellow').label('Gradient!')
    flow.Line()
    flow.Box().gradient_fill('blue', 'purple', False).label('Gradient!', color='white')
```

--------------------------------

### Switch and Fuse

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_pictorial.ipynb

Demonstrates drawing a switch and a fuse. This example requires the `schemdraw` and `schemdraw.elements` modules.

```python
import schemdraw
import schemdraw.elements as elm

d = schemdraw.Drawing()
d += elm.Switch()
d += elm.Fuse()
d.draw()
```

--------------------------------

### Basic Component Drawing with IEEE Style

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_styles.ipynb

Demonstrates drawing several common electronic components using the IEEE style. Ensure Schemdraw is installed and imported.

```python
import schemdraw
import schemdraw.elements as elm

elm.style(elm.STYLE_IEEE)
with schemdraw.Drawing():
    elm.Resistor()
    elm.ResistorVar()
    elm.Potentiometer()
    elm.Photoresistor()
    elm.Fuse()
```

--------------------------------

### Customizing Element Placement and Orientation

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_intcircuits.ipynb

This example demonstrates how to control the placement and orientation of circuit elements. Methods like `.right()`, `.up()`, and `.down()` are used to position elements relative to each other.

```python
import schemdraw
d = schemdraw.Drawing()
d += schemdraw.elements.Resistor(label='R1').up()
d += schemdraw.elements.Resistor(label='R2').right()
d += schemdraw.elements.Resistor(label='R3').down()
d += schemdraw.elements.Resistor(label='R4').left()
d.draw()
d.save('element_orientation.svg')
```

--------------------------------

### Install Schemdraw

Source: https://github.com/cdelker/schemdraw/blob/master/docs/usage/start.md

Install Schemdraw using pip. Optional dependencies can be included for Matplotlib or SVG math rendering.

```bash
pip install schemdraw
```

```bash
pip install schemdraw[matplotlib]
```

```bash
pip install schemdraw[svgmath]
```

```bash
pip install ./
```

--------------------------------

### Battery and Lamp

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_pictorial.ipynb

Demonstrates drawing a battery and a lamp symbol. This example requires the `schemdraw` and `schemdraw.elements` modules.

```python
import schemdraw
import schemdraw.elements as elm

d = schemdraw.Drawing()
d += elm.Battery()
d += elm.Lamp()
d.draw()
```

--------------------------------

### Drawing a Series of Components

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_canvas.ipynb

Example demonstrating how to draw multiple components in series. Requires the `schemdraw` and `schemdraw.elements as elm` imports.

```python
import schemdraw
import schemdraw.elements as elm

d = schemdraw.Drawing()
d.add(elm.Resistor())
d.add(elm.Capacitor())
d.add(elm.Ground())
d.draw()
```

--------------------------------

### Element Anchors and Connections

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_elements.ipynb

Explains how to use element anchors (e.g., 'start', 'end') for precise connections. Elements can be connected by referencing their anchors.

```python
import schemdraw
import schemdraw.elements as elm

d = schemdraw.Drawing()
res = d += elm.Resistor()
d += elm.Capacitor().at(res.end)
d.draw()
```

--------------------------------

### Customizing Component Appearance

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_canvas.ipynb

Example showing how to customize the color and label of a component. Requires the `schemdraw` and `schemdraw.elements as elm` imports.

```python
import schemdraw
import schemdraw.elements as elm

d = schemdraw.Drawing()
d.add(elm.Resistor().color('red').label('R1'))
d.draw()
```

--------------------------------

### Dependent Sources Example

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_placement.ipynb

Demonstrates the placement of source-controlled voltage and current elements. Use this to represent dependent sources in circuit diagrams.

```python
# Dependent sources
with schemdraw.Drawing() as d:
    elm.SourceControlledV().label('10 $V_1$', 'bot')
    elm.SourceControlledI().left().label('1A', 'top')
    elm.SourceControlledI().left().reverse().label('1A', 'top')
```

--------------------------------

### Basic Schemdraw Elements: Plug, Jack, CoaxConnect

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_elements.ipynb

Demonstrates the creation and drawing of a plug, a jack, and a coaxial connector using the Schemdraw library. Ensure the schemdraw library is installed.

```python
import schemdraw
import schemdraw.elements as elm

d = schemdraw.Drawing()
d += elm.Plug()
d += elm.Jack()
d += elm.CoaxConnect()
d.draw()
```

--------------------------------

### Basic Resistor with Label

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_styles.ipynb

Demonstrates how to create a basic resistor element with a label using Schemdraw. Ensure the schemdraw library is installed and imported.

```python
d = schemdraw.Drawing(font='serif', fontsize=20, lblofst=1)
d += elm.Resistor().label('Hello')
d.draw()
```

--------------------------------

### Drawing Circuits with Loops and Branches

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_pictorial.ipynb

This example demonstrates how to create circuit diagrams featuring loops and multiple branches using Schemdraw's drawing capabilities.

```python
import schemdraw
import schemdraw.elements as elm

d = schemdraw.Drawing()
d += elm.SourceV().label('V1')
d += elm.Line().right()
d += elm.Resistor().label('R1')
d += elm.Line().right()
d += elm.Resistor().label('R2')
d += elm.Line().up()
d += elm.Resistor().label('R3')
d += elm.Line().left()
d += elm.Line().down().length(d.unit)
d += elm.Ground()
d.draw()
d.save('loops_branches_labeled.svg')
```

--------------------------------

### Draw a circuit with different element anchor points for connections

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_flow.ipynb

This snippet demonstrates controlling connection points on elements. For example, connecting to the `start` or `end` of a wire. Use the `at=` argument when defining connections.

```python
import schemdraw
import schemdraw.elements as elm

d = schemdraw.Drawing()

w1 = d.add(elm.Wire('right', d=2))
d.add(elm.Resistor().at(w1.end))

d.add(elm.Wire().at(w1.start).left(d=1))

d.draw()
d.save('connection_anchor_points_circuit.svg')
```

--------------------------------

### Creating a Basic Circuit with Multiple Components

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_elements.ipynb

This example demonstrates the creation of a circuit schematic using various Schemdraw elements. It includes components like NPN transistors, lamps, switches, potentiometers, breakers, LEDs, and variable capacitors/resistors. Elements are positioned and styled using their respective methods and parameters.

```python
with schemdraw.Drawing():
    elm.BjtNpn(circle=True, circle_lw=5)
    elm.BjtNpn(arrowwidth=.4, arrowlength=.3).at((2, 0))
    elm.Lamp(filament_lw=1, filament_color='red').at((4, -1.5))
    elm.Lamp2(filament_lw=1, filament_color='blue').at((5.5, -1.5))
    elm.Switch(action='close', arrow_color='red', arrow_lw=1).at((0, -2)).right()
    elm.Potentiometer(tap_length=2).flip()
    elm.Breaker(arc_lw=1, arc_color='orange')
    elm.LED(arrow_color='red', arrowlength=.12)
    elm.CapacitorTrim(trim_lw=1, trim_color='purple').at((0, -4))
    elm.ResistorVar(arrow_lw=3, arrow_color='pink').at((6, -4))
    elm.CapacitorVar(arrow_lw=1, arrow_color='blue')
```

--------------------------------

### Point Initialization

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_backend.ipynb

Demonstrates the creation of a Point object with specified coordinates.

```python
Point((1, 1))
```

--------------------------------

### Drawing a Simple Amplifier Circuit

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_pictorial.ipynb

Example of drawing a basic amplifier circuit, including input, output, and power supply connections.

```python
import schemdraw
import schemdraw.elements as elm

d = schemdraw.Drawing()
d += elm.SourceV().label('Vin')
d += elm.Line().right()
d += elm.Resistor().label('R1')
d += elm.Line().right()
d += elm.Opamp().label('A1')
d += elm.Line().right()
d += elm.Resistor().label('Rout')
d += elm.Line().down()
d += elm.Ground()
d += elm.Line().up().length(d.unit/2)
d += elm.Line().left().length(d.unit*3)
d += elm.SourceV().up().label('+Vcc')
d += elm.Line().left().length(d.unit*3)
d += elm.SourceV().down().label('-Vee')
d.draw()
d.save('amplifier_circuit.svg')
```

--------------------------------

### Configure Integrated Circuit with Detailed Pins and Styles

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_intcircuits.ipynb

Demonstrates advanced configuration of `Ic` elements with custom pin names, labels, colors, font sizes, invert bubbles, and anchor points. Includes drawing the circuit and connecting other elements.

```python
# Test various aspects of ic() function
# including labels, pin labels, colors, fontsizes, invertbubbles, and anchors
ic = elm.Ic(pins=[
      elm.IcPin(name='>', pin='1', side='left'),
      elm.IcPin(name='K', pin='2', side='left', lblsize=10, color='red'),
      elm.IcPin(name='J', pin='3', side='left', invert=True),
      elm.IcPin(name='Q', pin='12', side='right'),
      elm.IcPin(name=r'$\\\overline{Q}$', pin='14', side='right', invert=True, anchorname='QBAR'),
      elm.IcPin(name='RST', pin='16', side='top', slot='2/3', rotation=65, invert=True, color='blue'),
      elm.IcPin(name='CLR', pin='17', side='top', slot='1/3', rotation=65, invert=True),
      elm.IcPin(name='ABC', pin='13', side='top', slot='3/3', rotation=65, invert=False),
      elm.IcPin(side='bot', pos=.6),
      elm.IcPin(side='bot', pos=.4)],
      edgepadH = 1,
      edgepadW = 1,
      leadlen=.4,
      slant=0,
      pinspacing=1
      )

with schemdraw.Drawing() as d:
    I = d.add(ic)
    elm.Line().right().at(I.QBAR)
    elm.Crystal().down().toy(I.Q)
    elm.Line().left().tox(I.Q)
```

--------------------------------

### Create BitField with compact configuration and labels

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_timing.ipynb

This example demonstrates creating a BitField with a `compact` configuration and custom labels for the lanes. It also shows a variation in bit counts for registers.

```python
logic.BitField.from_json('''
{
  "reg": [
    {name: 'IPO',   bits: 8,},
    {               bits: 7},
    {name: 'BRK',   bits: 5, type: 4},
    {name: 'CPK',   bits: 1},
    {name: 'Clear', bits: 3, type: 5},
    {               bits: 8}
  ],
  config: {lanes: 4, compact: true, hflip: true,
      label: {left: 0, right: ['a', 'b', 'c', 'd']}
}
''',
)
```

--------------------------------

### Simple Flowchart with Schemdraw

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_gallery.ipynb

Creates a basic flowchart with a start node, an arrow, and a decision point. Demonstrates the use of flow.Start, flow.Arrow, and flow.Decision elements.

```python
with schemdraw.Drawing() as d:
    flow.Start().label('START')
    flow.Arrow().down(d.unit/3)
    h = flow.Decision(S='YES').label('Hey, wait,\nthis flowchart\nis a trap!')
    flow.Line().down(d.unit/4)
    flow.Wire('c', k=3.5, arrow='->').to(h.E)
```

--------------------------------

### Draw Integrated Circuits with Custom Pins

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_intcircuits.ipynb

Defines custom pin configurations for an IC and draws two IC elements with different slant angles and positions. This example requires the schemdraw library to be installed and configured for SVG output.

```python
pins = [elm.IcPin('A', side='l'),
        elm.IcPin('B', side='l'),
        elm.IcPin('C', side='l'), 
        elm.IcPin('D', side='r'),
        elm.IcPin('E', side='r'),
        elm.IcPin('F', side='r'), 
        elm.IcPin('1', side='t'),
        elm.IcPin('2', side='t'),
        elm.IcPin('3', side='t'), 
        elm.IcPin('4', side='b'),
        elm.IcPin('5', side='b'),
        elm.IcPin('6', side='b'),]

with schemdraw.Drawing():
    elm.Ic(slant=-20, pins=pins)
    elm.Ic(slant=20, pins=pins).at((5, 0))
```

--------------------------------

### Instantiating and Configuring Analog FETs

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_elements.ipynb

Demonstrates the creation of AnalogNFet, AnalogPFet, and AnalogBiasedFet elements with all possible combinations of bulk, arrow, and offset_gate properties. Use this to explore the visual variations of each FET type.

```python
d = schemdraw.Drawing()
# check defaults and exhaustively test all analogFET options
d += elm.AnalogNFet()
d += elm.AnalogNFet(bulk=False, arrow=False, offset_gate=False)
d += elm.AnalogNFet(bulk=True,  arrow=False, offset_gate=False)
d += elm.AnalogNFet(bulk=False, arrow=True,  offset_gate=False)
d += elm.AnalogNFet(bulk=False, arrow=False, offset_gate=True )
d += elm.AnalogNFet(bulk=True,  arrow=True,  offset_gate=False)
d += elm.AnalogNFet(bulk=False, arrow=True,  offset_gate=True)
d += elm.AnalogNFet(bulk=True,  arrow=False, offset_gate=True )
d += elm.AnalogNFet(bulk=True,  arrow=True,  offset_gate=True )

d.here = (2,0)

d += elm.AnalogPFet()
d += elm.AnalogPFet(bulk=False, arrow=False, offset_gate=False)
d += elm.AnalogPFet(bulk=True,  arrow=False, offset_gate=False)
d += elm.AnalogPFet(bulk=False, arrow=True,  offset_gate=False)
d += elm.AnalogPFet(bulk=False, arrow=False, offset_gate=True )
d += elm.AnalogPFet(bulk=True,  arrow=True,  offset_gate=False)
d += elm.AnalogPFet(bulk=False, arrow=True,  offset_gate=True)
d += elm.AnalogPFet(bulk=True,  arrow=False, offset_gate=True )
d += elm.AnalogPFet(bulk=True,  arrow=True,  offset_gate=True )

d.here = (4,0)

d += elm.AnalogBiasedFet()
d += elm.AnalogBiasedFet(bulk=False, arrow=False, offset_gate=False)
d += elm.AnalogBiasedFet(bulk=True,  arrow=False, offset_gate=False)
d += elm.AnalogBiasedFet(bulk=False, arrow=True,  offset_gate=False)
d += elm.AnalogBiasedFet(bulk=False, arrow=False, offset_gate=True )
d += elm.AnalogBiasedFet(bulk=True,  arrow=True,  offset_gate=False)
d += elm.AnalogBiasedFet(bulk=False, arrow=True,  offset_gate=True)
d += elm.AnalogBiasedFet(bulk=True,  arrow=False, offset_gate=True )
d += elm.AnalogBiasedFet(bulk=True,  arrow=True,  offset_gate=True )

d.draw()
```

--------------------------------

### Basic Element Placement with DSP

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_placement.ipynb

Demonstrates placing a Mixer element and an Arrow with specific angles and z-order.

```python
from schemdraw import dsp
with schemdraw.Drawing() as d:
    mx = dsp.Mixer().theta(45)
    elm.Arrow(double=True).color('red').zorder(10).theta(45)
    dsp.Mixer()
```

--------------------------------

### Adding Multiple Components to a Circuit

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_intcircuits.ipynb

This example shows how to add multiple components, such as resistors and capacitors, to a circuit diagram. Components are added sequentially to the drawing object.

```python
import schemdraw
d = schemdraw.Drawing()
d += schemdraw.elements.Resistor(label='R1')
d += schemdraw.elements.Capacitor(label='C1').right()
d.draw()
d.save('multiple_components.svg')
```

--------------------------------

### Import Schemdraw and Logic Module

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_timing.ipynb

Initializes Schemdraw and imports the logic module for timing diagram creation. Sets the output backend to SVG.

```python
import schemdraw
from schemdraw import logic

schemdraw.use('svg')
```

--------------------------------

### Start

Source: https://github.com/cdelker/schemdraw/blob/master/docs/classes/flow.md

An alias for the Terminal element, representing the start of a flowchart.

```APIDOC
## Start

### Description
Flowchart start terminal. Alias of `Terminal`.
```

--------------------------------

### Get Image Data

Source: https://github.com/cdelker/schemdraw/blob/master/docs/classes/drawing.md

Get the drawing's image data as a byte array in a specified format.

```APIDOC
## get_imagedata

### Description
Get image data as bytes array

### Parameters
* **fmt** (ImageFormat | ImageType) - Format or file extension of the image type. SVG backend only supports ‘svg’ format.

### Returns
Image data as bytes
```

--------------------------------

### Create Custom IC and Header with Connections

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_elements2.ipynb

Demonstrates creating a custom Integrated Circuit (IC) element with specified pins and a header element. It then draws connecting lines between the header pins and the IC.

```python
with schemdraw.Drawing():
    D1 = (elm.Ic(pins=[elm.IcPin(name='A', side='t', slot='1/4'),
                       elm.IcPin(name='B', side='t', slot='2/4'),
                       elm.IcPin(name='C', side='t', slot='3/4'),
                       elm.IcPin(name='D', side='t', slot='4/4')]))
    D2 = elm.Header(rows=4).at((5,4))
    elm.RightLines(n=4).at(D2.pin1).to(D1.D)
```

--------------------------------

### Complex Circuit Example in Schemdraw

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_elements.ipynb

A more complex circuit diagram showcasing the combination of various elements, including loops and multiple components. This example highlights the library's capability for intricate designs.

```python
import schemdraw
import schemdraw.elements as elm
d = schemdraw.Drawing()
# Simple Op-Amp circuit
d += elm.Opamp().up()
d += (R1 := elm.Resistor().left().label('10k'))
d += (R2 := elm.Resistor().down().label('100k'))
d += elm.Ground()
d += elm.Line().right().at(R1.start).toy(d.last)
d += elm.SourceV().up().label('5V')
d.draw()
```

--------------------------------

### Create and Style an Optocoupler

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_elements2.ipynb

Instantiates an Optocoupler element with a light gray fill and then applies a blue fill to it. This demonstrates basic element creation and styling.

```python
elm.Optocoupler(boxfill='lightgray').fill('blue')
```

--------------------------------

### labelsize

Source: https://github.com/cdelker/schemdraw/blob/master/docs/classes/flow.md

Utility function to get the unit size of a label and its padding.

```APIDOC
## labelsize(label, pad)

### Description
Get unit size of label and padding.

### Parameters
* **label** (str) - The label text.
* **pad** (float) - The padding around the label.
```

--------------------------------

### Get Bounding Box

Source: https://github.com/cdelker/schemdraw/blob/master/docs/classes/drawing.md

Retrieve the bounding box coordinates of the entire drawing.

```APIDOC
## get_bbox

### Description
Get drawing bounding box

### Returns
BBox
```

--------------------------------

### VacuumTube Element with Split Options

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_elements2.ipynb

Illustrates creating VacuumTube elements with 'split' options for left and right configurations, and adding labels to specific connection points like cathode and anode. Also shows basic line drawing from these connection points.

```python
with schemdraw.Drawing():
    t = (elm.VacuumTube(split='left')
            .label('1', 'cathode')
            .label('2', 'anode')
        )
    elm.Line().down().at(t.cathode).length(1)
    elm.Line().up().at(t.anode).length(.5)

    t2 = (elm.VacuumTube(split='right')
            .label('3', 'cathode_R')
            .label('4', 'anode')
        ).at((3, 0))
    elm.Line().down().at(t2.cathode_R).length(1)
    elm.Line().up().at(t2.anode).length(.5)

    t3 = (elm.VacuumTube(cathode='cold', heater=False).at((7, 0))
            .label('1', 'cathode')
            .label('2', 'anode')
        )
    elm.Line().down().at(t3.cathode).length(.5)
    elm.Line().up().at(t3.anode).length(.5)
```

--------------------------------

### Element2Term Methods

Source: https://github.com/cdelker/schemdraw/blob/master/docs/classes/drawing.md

Methods specific to Element2Term for defining start and end points and connections.

```APIDOC
## dot(open: bool = False)

### Description
Add a dot to the end of the element.

### Method
dot

### Endpoint
N/A (SDK Method)

### Parameters
- **open** (bool) - Optional - If True, creates an open dot. Defaults to False.
```

```APIDOC
## down(length: float | None = None)

### Description
Set the direction to down and optionally specify the length.

### Method
down

### Endpoint
N/A (SDK Method)

### Parameters
- **length** (float | None) - Optional - The length of the downward segment.
```

```APIDOC
## endpoints(start: Tuple[float, float] | Point, end: Tuple[float, float] | Point)

### Description
Sets the absolute start and end points of the element.

### Method
endpoints

### Endpoint
N/A (SDK Method)

### Parameters
- **start** (Tuple[float, float] | Point) - The absolute starting coordinates.
- **end** (Tuple[float, float] | Point) - The absolute ending coordinates.
```

```APIDOC
## idot(open: bool = False)

### Description
Add a dot to the input/start of the element.

### Method
idot

### Endpoint
N/A (SDK Method)

### Parameters
- **open** (bool) - Optional - If True, creates an open dot. Defaults to False.
```

```APIDOC
## left(length: float | None = None)

### Description
Set the direction to left and optionally specify the length.

### Method
left

### Endpoint
N/A (SDK Method)

### Parameters
- **length** (float | None) - Optional - The length of the leftward segment.
```

```APIDOC
## length(length: float)

### Description
Sets the total length of the element.

### Method
length

### Endpoint
N/A (SDK Method)

### Parameters
- **length** (float) - The total length of the element.
```

```APIDOC
## right(length: float | None = None)

### Description
Set the direction to right and optionally specify the length.

### Method
right

### Endpoint
N/A (SDK Method)

### Parameters
- **length** (float | None) - Optional - The length of the rightward segment.
```

```APIDOC
## shift(shift: float)

### Description
Shift the element within its leads to one end or the other. The shift parameter should be between -1 and 1, indicating the fraction of the lead extension.

### Method
shift

### Endpoint
N/A (SDK Method)

### Parameters
- **shift** (float) - The shift factor, between -1 and 1.
```

```APIDOC
## to(xy: Tuple[float, float] | Point, dx: float = 0, dy: float = 0)

### Description
Sets the ending position of the element.

### Method
to

### Endpoint
N/A (SDK Method)

### Parameters
- **xy** (Tuple[float, float] | Point) - The ending position coordinates.
- **dx** (float) - Optional - X-offset from the xy position. Defaults to 0.
- **dy** (float) - Optional - Y-offset from the xy position. Defaults to 0.
```

```APIDOC
## tox(x: float | XY | [Element](#schemdraw.elements.Element))

### Description
Sets the ending x-position of the element (for horizontal elements).

### Method
tox

### Endpoint
N/A (SDK Method)

### Parameters
- **x** (float | XY | Element) - The target x-coordinate or element.
```

```APIDOC
## toy(y: float | XY | [Element](#schemdraw.elements.Element))

### Description
Sets the ending y-position of the element (for vertical elements).

### Method
toy

### Endpoint
N/A (SDK Method)

### Parameters
- **y** (float | XY | Element) - The target y-coordinate or element.
```

```APIDOC
## up(length: float | None = None)

### Description
Set the direction to up and optionally specify the length.

### Method
up

### Endpoint
N/A (SDK Method)

### Parameters
- **length** (float | None) - Optional - The length of the upward segment.
```

--------------------------------

### Terminal

Source: https://github.com/cdelker/schemdraw/blob/master/docs/classes/flow.md

Represents a flowchart start or end terminal. It can be configured with width (w) and height (h).

```APIDOC
## Terminal

### Description
Flowchart start/end terminal.

### Parameters
* **w** (float) - Width of box
* **h** (float) - Height of box

### Anchors
* 16 compass points (N, S, E, W, NE, NNE, etc.)
```

--------------------------------

### Custom Element Styles with Partial

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_placement.ipynb

Shows how to define custom element styles using partial functions for different scales (ResistorMini, ResistorJumbo) and their application in a circuit.

```python
elm.style({'ResistorMini': partial(elm.Resistor, scale=.5),
           'ResistorJumbo': partial(elm.Resistor, scale=1.5)})
with schemdraw.Drawing() as d:
    op = elm.Opamp(leads=True)
    elm.Line().down().at(op.in2).length(d.unit/4)
    elm.Ground(lead=False)
    Rin = elm.ResistorMini().at(op.in1).left().idot().label('$R_{in}$', loc='bot').label('$v_{in}$', loc='left')
    elm.Line().up().at(op.in1).length(d.unit/2)
    elm.ResistorJumbo().tox(op.out).label('$R_f$')
    elm.Line().toy(op.out).dot()
    elm.Line().right().at(op.out).length(d.unit/4).label('$v_{o}$', loc='right')
```

--------------------------------

### Get Segments

Source: https://github.com/cdelker/schemdraw/blob/master/docs/classes/drawing.md

Retrieve a flattened list of all drawing segments, including lines, text, and shapes.

```APIDOC
## get_segments

### Description
Get flattened list of all segments in the drawing

### Returns
list[[Segment](segments.md#schemdraw.segments.Segment) | [SegmentText](segments.md#schemdraw.segments.SegmentText) | [SegmentPoly](segments.md#schemdraw.segments.SegmentPoly) | [SegmentArc](segments.md#schemdraw.segments.SegmentArc) | [SegmentCircle](segments.md#schemdraw.segments.SegmentCircle) | [SegmentBezier](segments.md#schemdraw.segments.SegmentBezier) | [SegmentPath](segments.md#schemdraw.segments.SegmentPath) | [SegmentImage](segments.md#schemdraw.segments.SegmentImage)]
```

--------------------------------

### Configure Op-amp with Sign and Leads

Source: https://github.com/cdelker/schemdraw/blob/master/docs/elements/electrical.md

Customize the Opamp element by setting the sign parameter to False or enabling optional leads.

```python
Opamp(sign=False)
Opamp(leads=True)
```

--------------------------------

### Get Image Data

Source: https://github.com/cdelker/schemdraw/blob/master/docs/classes/drawing.md

Obtain the schematic as a byte array in a specified image format, such as SVG.

```python
svg_data = d.get_imagedata(fmt='svg')

```

--------------------------------

### Basic Element Placement in Schemdraw

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_elements2.ipynb

Demonstrates the fundamental way to place elements in a schematic using Schemdraw. Requires importing the library.

```python
import schemdraw
import schemdraw.elements as elm

d = schemdraw.Drawing()
d.add(elm.Resistor())
d.draw()
d.save('resistor.svg')
```

--------------------------------

### Basic Element Creation in Schemdraw

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_elements.ipynb

Demonstrates the creation and placement of basic elements like lines and arrows. Ensure the 'schemdraw' library is imported.

```python
import schemdraw
import schemdraw.elements as elm
d = schemdraw.Drawing()
d += elm.Line().right().label('L1')
d += elm.Arrow().right().label('A1')
d.draw()
```

--------------------------------

### Draw a basic circuit with Schemdraw

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_flow.ipynb

This snippet demonstrates the fundamental usage of Schemdraw to draw a simple circuit. It initializes a drawing, adds elements, and displays the result. Ensure Schemdraw is installed and imported.

```python
import schemdraw
import schemdraw.elements as elm

d = schemdraw.Drawing()
d += elm.Resistor()
d.draw()
d.save('basic_circuit.svg')
```

--------------------------------

### Drawing with Directions and Labels

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_pictorial.ipynb

This example shows how to specify directions for drawing elements and add labels to them.

```python
import schemdraw
import schemdraw.elements as elm

d = schemdraw.Drawing()
d += elm.Resistor().label('R1')
d += elm.Line().right()
d += elm.Capacitor().label('C1')
d += elm.Line().down()
d += elm.SourceV().label('V1')
d += elm.Line().left()
d += elm.Resistor().label('R2')
d += elm.Line().up()
d.draw()
d.save('directional_labeled.svg')
```

--------------------------------

### RightLines Element

Source: https://github.com/cdelker/schemdraw/blob/master/docs/classes/electrical.md

Represents right-angle multi-line connectors. Use at() and to() methods to specify starting and ending locations.

```APIDOC
## schemdraw.elements.connectors.RightLines(*args, **kwargs)

Right-angle multi-line connectors

Use at() and to() methods to specify starting and ending
location.

The default lines are spaced to provide connection to
pins with default spacing on Ic element or connector
such as a Header.

* **Parameters:**
  * **n** – Number of parallel lines
  * **dy** – Distance between parallel lines [default: 0.6]

#### delta(dx: float = 0, dy: float = 0) → [Element](drawing.md#schemdraw.elements.Element)

Specify ending position relative to start position

#### to(xy: Tuple[float, float] | Point) → [Element](drawing.md#schemdraw.elements.Element)

Specify ending position of OrthoLines
```

--------------------------------

### OrthoLines Element

Source: https://github.com/cdelker/schemdraw/blob/master/docs/classes/electrical.md

Represents orthogonal multiline connectors. Use at() and to() methods to specify starting and ending locations.

```APIDOC
## schemdraw.elements.connectors.OrthoLines(*args, **kwargs)

Orthogonal multiline connectors

Use at() and to() methods to specify starting and
ending location of OrthoLines.

The default lines are spaced to provide connection to
pins with default spacing on Ic element or connector
such as a Header.

* **Parameters:**
  * **n** – Number of parallel lines
  * **dy** – Distance between parallel lines [default: 0.6]
  * **xstart** – Fractional distance (0-1) to start vertical
    portion of first ortholine

#### delta(dx: float = 0, dy: float = 0) → [Element](drawing.md#schemdraw.elements.Element)

Specify ending position relative to start position

#### to(xy: Tuple[float, float] | Point) → [Element](drawing.md#schemdraw.elements.Element)

Specify ending position of OrthoLines
```

--------------------------------

### Draw a circuit with custom element properties

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_flow.ipynb

This example shows how to set custom properties for elements, such as line width and stroke color. These properties are passed as keyword arguments to the element constructor or using the `style=` attribute.

```python
import schemdraw
import schemdraw.elements as elm

d = schemdraw.Drawing()

d += elm.Resistor(label='R1', lw=3, color='blue') # lw is line width
d += elm.Wire(d=2)
d += elm.Capacitor(label='C1', style='stroke-width:2;stroke:red;fill:none')

d.draw()
d.save('custom_properties_circuit.svg')
```

--------------------------------

### Basic Drawing with Context Manager

Source: https://github.com/cdelker/schemdraw/blob/master/docs/usage/start.md

Create a circuit diagram using the Drawing context manager. Elements are added within the 'with' block and the drawing is displayed/saved upon exiting.

```python
import schemdraw
import schemdraw.elements as elm

with schemdraw.Drawing() as d:
    d += elm.Resistor()
    d += elm.Capacitor()
    d += elm.SourceV()

# The drawing is displayed and saved automatically upon exiting the 'with' block.
```

--------------------------------

### Clone and test Fritzing-Library parts

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_pictorial.ipynb

This commented-out code demonstrates how to clone the Fritzing-Library and then iterate through all .fzpz files to test their anchor positions using the testpart function.

```python
# Clone https://github.com/adafruit/Fritzing-Library to test a bunch of parts
# and verify anchor positions

#parts = glob.glob('./Fritzing-Library/parts/*.fzpz')
#for part in parts:
#    testpart(part)
```

--------------------------------

### Get Drawing Bounding Box

Source: https://github.com/cdelker/schemdraw/blob/master/docs/classes/drawing.md

Retrieve the bounding box of the entire drawing, which can be useful for positioning or scaling.

```python
bbox = d.get_bbox()

```

--------------------------------

### Drawing a Circuit with a Custom Element Lamp

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_pictorial.ipynb

Shows how to define a custom lamp element.

```python
import schemdraw
import schemdraw.elements.circuit as elm_c

class MyLamp(elm_c.Element):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.segments.append(elm_c.Lamp())

d = schemdraw.Drawing()
d += MyLamp()
d.draw()
```

--------------------------------

### Draw a circuit with custom element sizes

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_flow.ipynb

This example shows how to control the size of circuit elements. While elements have default sizes, you can override them using arguments like `size=` or by manipulating the underlying SVG path.

```python
import schemdraw
import schemdraw.elements as elm

d = schemdraw.Drawing()

d += elm.Resistor(label='Default Size')
d += elm.Resistor(label='Large Size', size=2)
d += elm.Resistor(label='Small Size', size=0.5)

d.draw()
d.save('element_sizes_circuit.svg')
```

--------------------------------

### Drawing with Loops

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_elements.ipynb

Illustrates creating closed loops in a circuit diagram. Elements can be connected back to their starting points.

```python
import schemdraw
import schemdraw.elements as elm

d = schemdraw.Drawing()
d += elm.Line().right(2)
d += elm.Line().up(1)
d += elm.Line().left(2)
d += elm.Line().down(1).at(d.last)
d.draw()
```

--------------------------------

### Get Drawing Segments

Source: https://github.com/cdelker/schemdraw/blob/master/docs/classes/drawing.md

Access a flattened list of all segments that make up the drawing. This can be useful for advanced manipulation or analysis.

```python
segments = d.get_segments()

```

--------------------------------

### Capacitor and Ground Symbol

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_pictorial.ipynb

Illustrates drawing a capacitor and a ground symbol. This example requires the `schemdraw` and `schemdraw.elements` modules.

```python
import schemdraw
import schemdraw.elements as elm

d = schemdraw.Drawing()
d += elm.Capacitor()
d += elm.Ground()
d.draw()
```

--------------------------------

### Drawing a Circuit with a Custom Element Thermostat

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_pictorial.ipynb

Demonstrates defining a custom thermostat element.

```python
import schemdraw
import schemdraw.elements.circuit as elm_c

class MyThermostat(elm_c.Element):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.segments.append(elm_c.Thermostat())

d = schemdraw.Drawing()
d += MyThermostat()
d.draw()
```

--------------------------------

### Create and Label a Pentode in Schemdraw

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_elements2.ipynb

Demonstrates how to instantiate a Pentode element, label its pins, and add connecting lines to represent electrical connections. Use this for drawing vacuum tube circuits.

```python
with schemdraw.Drawing():
    t = (elm.Pentode()
             .label('1', 'cathode')
             .label('2', 'anode')
             .label('3', 'suppressor')
             .label('4', 'screen_R')
             .label('5', 'control')
        )
    elm.Line().down().at(t.cathode).length(1)
    elm.Line().up().at(t.anode).length(.5)
    elm.Line().left().at(t.suppressor).length(1)
    elm.Line().right().at(t.screen_R).length(1)
    elm.Line().left().at(t.control).length(1)

    t2 = elm.Pentode(strap=True).at((4, 0))
```

--------------------------------

### Drawing a Series Circuit

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_pictorial.ipynb

Illustrates how to draw a circuit with components in series. This example uses 'schemdraw.elements.all' for component definitions.

```python
import schemdraw
import schemdraw.elements as elm

d = schemdraw.Drawing()
d += elm.Resistor().label('R1')
d += elm.Resistor().label('R2')
d += elm.SourceV().label('V1')
d.draw()
d.save('series_circuit.svg')
```

--------------------------------

### Draw a circuit with custom element colors

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_flow.ipynb

This example demonstrates how to change the color of circuit elements using the `color=` argument. This allows for visual differentiation of components or highlighting specific parts of the circuit.

```python
import schemdraw
import schemdraw.elements as elm

d = schemdraw.Drawing()

d += elm.Resistor().color('red').label('R1 (Red)')
d += elm.Wire().color('blue')
d += elm.Capacitor().color('green').label('C1 (Green)')
d += elm.Wire().color('purple')
d += elm.SourceV().color('orange').label('V1 (Orange)')

d.draw()
d.save('colored_circuit.svg')
```

--------------------------------

### Gap

Source: https://github.com/cdelker/schemdraw/blob/master/docs/classes/electrical.md

Provides a gap for labeling port voltages, for example. Draws nothing, but provides space to attach a label.

```APIDOC
## Gap

### Description
Gap for labeling port voltages, for example. Draws nothing, but provides place to attach a label such as (‘+’, ‘V’, ‘-‘).

### Keyword Arguments:
* **lblloc** – Label location within the gap [center]
* **lblalign** – Label alignment [(center, center)]
* **lblofst** – Offset to label [0]
```

--------------------------------

### Drawing a Ground Symbol

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_canvas.ipynb

Example of drawing a ground symbol in Schemdraw. Requires the `schemdraw` and `schemdraw.elements as elm` imports.

```python
import schemdraw
import schemdraw.elements as elm

d = schemdraw.Drawing()
d.add(elm.Ground()) 
d.draw()
```

--------------------------------

### Draw Logic Gates with Lead Extensions

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_placement.ipynb

Demonstrates drawing various logic gates (NOT, Buffer) and extending their input/output leads for connections.

```python
with schemdraw.Drawing() as d:
    n = logic.Not()
    logic.NotNot().up()
    logic.Buf().right().reverse()
    logic.Line().up().length(d.unit/2)
    logic.Not().left().tox(n.start).reverse()
    logic.Buf().down().toy(n.start)
```

--------------------------------

### Drawing a Capacitor

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_canvas.ipynb

Example of drawing a basic capacitor element in Schemdraw. Requires the `schemdraw` and `schemdraw.elements as elm` imports.

```python
import schemdraw
import schemdraw.elements as elm

d = schemdraw.Drawing()
d.add(elm.Capacitor())
d.draw()
```

--------------------------------

### Drawing a Resistor

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_canvas.ipynb

Example of drawing a basic resistor element in Schemdraw. Requires the `schemdraw` and `schemdraw.elements as elm` imports.

```python
import schemdraw
import schemdraw.elements as elm

d = schemdraw.Drawing()
d.add(elm.Resistor())
d.draw()
```

--------------------------------

### Sequential Element Placement

Source: https://github.com/cdelker/schemdraw/blob/master/test/test_placement.ipynb

Shows how to place elements sequentially, using the anchor point of one element to position another.

```python
with schemdraw.Drawing() as d:
    elm.Resistor()
    q = logic.Not(anchor='in1')
    elm.Capacitor().at(q.out).down()
```