# Grapheme TK

> Protein-ligand interaction visualization and molecular surface depiction

## Links
- [Full Documentation](https://docs.eyesopen.com/toolkits/python/graphemetk/index.html)
- [Theory](https://docs.eyesopen.com/toolkits/python/graphemetk/theory.html)
- [Examples](https://docs.eyesopen.com/toolkits/python/graphemetk/examples_summary.html)
- [API Reference](https://docs.eyesopen.com/toolkits/python/graphemetk/api.html)

## Core API - Function Quick Reference

### Active Site Visualization
```
OERenderActiveSite(image: OEImageBase, asite: OE2DActiveSiteDisplay, opts: OE2DActiveSiteDisplayOptions) -> bool
  Use for: Rendering protein-ligand active site interactions with 2D diagrams
  Example: OERenderActiveSite(image, asite, opts)
  See: https://docs.eyesopen.com/toolkits/python/graphemetk/OEGraphemeFunctions/OERenderActiveSite.html

OEPrepareActiveSiteDepiction(asite: OEInteractionHintContainer) -> OE2DActiveSiteDisplay
  Use for: Preparing active site data for 2D depiction from 3D structure
  Example: asite = OEPrepareActiveSiteDepiction(hintcontainer)
  See: https://docs.eyesopen.com/toolkits/python/graphemetk/OEGraphemeFunctions/OEPrepareActiveSiteDepiction.html

OEDrawActiveSiteLegend(image: OEImageBase, opts: OE2DActiveSiteLegendDisplayOptions) -> bool
  Use for: Adding interaction type legend to active site diagrams
  Example: OEDrawActiveSiteLegend(image, legendopts)
  See: https://docs.eyesopen.com/toolkits/python/graphemetk/OEGraphemeFunctions/OEDrawActiveSiteLegend.html

OE2DActiveSiteDisplay(hintcontainer: OEInteractionHintContainer, opts: OE2DActiveSiteDisplayOptions)
  Use for: Creating active site display object with customizable rendering options
  Example: asite = OE2DActiveSiteDisplay(hintcontainer, opts)
  See: https://docs.eyesopen.com/toolkits/python/graphemetk/OEGraphemeClasses/OE2DActiveSiteDisplay.html
```

### Molecular Surface Depiction
```
OEDraw2DSurface(image: OEImageBase, mol: OEMolBase) -> bool
  Use for: Drawing 2D molecular surface around a molecule
  Example: OEDraw2DSurface(image, mol)
  See: https://docs.eyesopen.com/toolkits/python/graphemetk/OEGraphemeFunctions/OEDraw2DSurface.html

OEGet2DSurfaceArcs(mol: OEMolBase, arcfxn: OESurfaceArcFxnBase = None) -> OESurfaceArc iterator
  Use for: Getting surface arc data for custom surface rendering
  Example: for arc in OEGet2DSurfaceArcs(mol): process(arc)
  See: https://docs.eyesopen.com/toolkits/python/graphemetk/OEGraphemeFunctions/OEGet2DSurfaceArcs.html

OESetSurfaceArcFxn(mol: OEMolBase, arcfxn: OESurfaceArcFxnBase) -> bool
  Use for: Setting custom arc drawing function for molecule surface
  Example: OESetSurfaceArcFxn(mol, OEDefaultArcFxn(penwidth))
  See: https://docs.eyesopen.com/toolkits/python/graphemetk/OEGraphemeFunctions/OESetSurfaceArcFxn.html

OEDrawSurfaceArc(image: OEImageBase, arc: OESurfaceArc, arcfxn: OESurfaceArcFxnBase) -> bool
  Use for: Drawing individual surface arc with custom styling
  Example: OEDrawSurfaceArc(image, arc, arcfxn)
  See: https://docs.eyesopen.com/toolkits/python/graphemetk/OEGraphemeFunctions/OEDrawSurfaceArc.html
```

### Complex Surface Visualization
```
OEAddComplexSurfaceArcs(complex: OEGraphMol, arcfxn: OEComplexSurfaceArcFxnBase) -> bool
  Use for: Adding surface arcs to protein-ligand complex with different styles for buried/solvent/cavity regions
  Example: OEAddComplexSurfaceArcs(complex, arcfxn)
  See: https://docs.eyesopen.com/toolkits/python/graphemetk/OEGraphemeFunctions/OEAddComplexSurfaceArcs.html
```

### 3D to 2D Depiction
```
OEPrepareDepictionFrom3D(mol: OEMolBase, opts: OEDepictionFrom3DOptions = None) -> bool
  Use for: Converting 3D molecule coordinates to 2D depiction layout
  Example: OEPrepareDepictionFrom3D(mol)
  See: https://docs.eyesopen.com/toolkits/python/graphemetk/OEGraphemeFunctions/OEPrepareDepictionFrom3D.html

OEPrepareAlignedDepictionFrom3D(refmol: OEMolBase, fitmol: OEMolBase, opts: OEAlignedDepictionFrom3DOptions = None) -> bool
  Use for: Creating aligned 2D depiction from 3D structures for comparison
  Example: OEPrepareAlignedDepictionFrom3D(refmol, fitmol)
  See: https://docs.eyesopen.com/toolkits/python/graphemetk/OEGraphemeFunctions/OEPrepareAlignedDepictionFrom3D.html
```

### Shape and Color Overlap Visualization
```
OERenderShapeOverlap(image: OEImageBase, display: OEShapeOverlapDisplay) -> bool
  Use for: Rendering shape overlap between query and fit molecules
  Example: OERenderShapeOverlap(image, display)
  See: https://docs.eyesopen.com/toolkits/python/graphemetk/OEGraphemeFunctions/OERenderShapeOverlap.html

OERenderColorOverlap(image: OEImageBase, opts: OEColorOverlapDisplayOptions) -> bool
  Use for: Rendering color force field overlap visualization
  Example: OERenderColorOverlap(image, opts)
  See: https://docs.eyesopen.com/toolkits/python/graphemetk/OEGraphemeFunctions/OERenderColorOverlap.html

OEDrawROCSScores(image: OEImageBase, refmol: OEMolBase, fitmol: OEMolBase) -> bool
  Use for: Drawing ROCS shape and color scores on overlap visualization
  Example: OEDrawROCSScores(image, refmol, fitmol)
  See: https://docs.eyesopen.com/toolkits/python/graphemetk/OEGraphemeFunctions/OEDrawROCSScores.html
```

### Property Map Visualization
```
OE2DPropMap(mol: OEMolBase) -> OE2DPropMap
  Use for: Creating 2D property map for visualizing molecular properties
  Example: propmap = OE2DPropMap(mol)
  See: https://docs.eyesopen.com/toolkits/python/graphemetk/OEGraphemeClasses/OE2DPropMap.html

OESetup2DPropMap(propmap: OE2DPropMap, setup: int) -> bool
  Use for: Configuring property map with predefined setup (BFactor, Contact, etc.)
  Example: OESetup2DPropMap(propmap, OE2DPropMapSetup_BFactor)
  See: https://docs.eyesopen.com/toolkits/python/graphemetk/OEGraphemeFunctions/OESetup2DPropMap.html

OERenderBFactorMap(image: OEImageBase, propmap: OE2DPropMap) -> bool
  Use for: Rendering B-factor property map visualization
  Example: OERenderBFactorMap(image, propmap)
  See: https://docs.eyesopen.com/toolkits/python/graphemetk/OEGraphemeFunctions/OERenderBFactorMap.html

OERenderContactMap(image: OEImageBase, propmap: OE2DPropMap) -> bool
  Use for: Rendering protein-ligand contact map visualization
  Example: OERenderContactMap(image, propmap)
  See: https://docs.eyesopen.com/toolkits/python/graphemetk/OEGraphemeFunctions/OERenderContactMap.html
```

### Annotation and Highlighting
```
OEAddGlyph(image: OEImageBase, glyph: OEAtomGlyphBase/OEBondGlyphBase, atom/bond: OEAtomBase/OEBondBase) -> bool
  Use for: Adding visual glyphs (circles, arrows, etc.) to atoms or bonds
  Example: OEAddGlyph(image, OEAtomGlyphCircle(), atom)
  See: https://docs.eyesopen.com/toolkits/python/graphemetk/OEGraphemeFunctions/OEAddGlyph.html

OEAddLigandHighlighting(asite: OE2DActiveSiteDisplay, style: OEHighlightStyle) -> bool
  Use for: Adding highlighting to ligand in active site display
  Example: OEAddLigandHighlighting(asite, highlightstyle)
  See: https://docs.eyesopen.com/toolkits/python/graphemetk/OEGraphemeFunctions/OEAddLigandHighlighting.html

OEAddResidueHighlighting(asite: OE2DActiveSiteDisplay, residue: OEResidue, style: OEHighlightStyle) -> bool
  Use for: Adding highlighting to specific residue in active site
  Example: OEAddResidueHighlighting(asite, residue, highlightstyle)
  See: https://docs.eyesopen.com/toolkits/python/graphemetk/OEGraphemeFunctions/OEAddResidueHighlighting.html
```

### Peptide Visualization
```
OEDrawPeptide(image: OEImageBase, mol: OEMolBase, opts: OEPeptideDisplayOptions) -> bool
  Use for: Drawing peptide sequence with customizable labeling
  Example: OEDrawPeptide(image, peptide, opts)
  See: https://docs.eyesopen.com/toolkits/python/graphemetk/OEGraphemeFunctions/OEDrawPeptide.html
```

### Ramachandran Plot
```
OERenderRamachandranPlot(image: OEImageBase, plot: OERamachandranPlot) -> bool
  Use for: Rendering Ramachandran plot for protein structure validation
  Example: OERenderRamachandranPlot(image, plot)
  See: https://docs.eyesopen.com/toolkits/python/graphemetk/OEGraphemeFunctions/OERenderRamachandranPlot.html
```

### Interactive Features
```
OEGetNearestResidue(asite: OE2DActiveSiteDisplay, x: float, y: float) -> OENearestResidue
  Use for: Finding residue at specific coordinates for interactive SVG
  Example: nearest = OEGetNearestResidue(asite, x, y)
  See: https://docs.eyesopen.com/toolkits/python/graphemetk/OEGraphemeFunctions/OEGetNearestResidue.html

OEGetNearestAtom(disp: OE2DMolDisplay, x: float, y: float) -> OEAtomBase
  Use for: Finding atom at specific coordinates for interactive features
  Example: atom = OEGetNearestAtom(disp, x, y)
  See: https://docs.eyesopen.com/toolkits/python/graphemetk/OEGraphemeFunctions/OEGetNearestAtom.html
```

## Common Patterns - Complete Working Examples

### Pattern: Basic Active Site Visualization
```python
from openeye import oechem, oedepict, oegrapheme

# Read protein-ligand complex
ifs = oechem.oemolistream("complex.pdb")
protein = oechem.OEGraphMol()
oechem.OEReadMolecule(ifs, protein)

# Generate interaction hints and prepare display
asite = oechem.OEInteractionHintContainer(protein, oechem.OEIsLigand())
opts = oegrapheme.OE2DActiveSiteDisplayOptions()
adisp = oegrapheme.OEPrepareActiveSiteDepiction(asite, opts)

# Render to image
image = oedepict.OEImage(800, 600)
oegrapheme.OERenderActiveSite(image, adisp, opts)
oedepict.OEWriteImage("activesite.png", image)
```
Use when: You need to visualize protein-ligand interactions in 2D with automatic interaction detection

### Pattern: Custom Surface Arc Styling
```python
from openeye import oechem, oedepict, oegrapheme

# Create molecule and prepare 2D coordinates
mol = oechem.OEGraphMol()
oechem.OESmilesToMol(mol, "c1ccccc1")
oedepict.OEPrepareDepiction(mol)

# Set custom surface arc function
arcfxn = oegrapheme.OEDefaultArcFxn(oechem.OEBluePen)
oegrapheme.OESetSurfaceArcFxn(mol, arcfxn)

# Draw molecule with surface
image = oedepict.OEImage(400, 400)
disp = oedepict.OE2DMolDisplay(mol)
oegrapheme.OEDraw2DSurface(image, disp)
oedepict.OERenderMolecule(image, disp)
oedepict.OEWriteImage("surface.png", image)
```
Use when: You want to customize the appearance of molecular surfaces with specific colors or styles

### Pattern: Complex Surface with Multiple Arc Styles
```python
from openeye import oechem, oedepict, oegrapheme, oebio

# Read protein-ligand complex
complex = oechem.OEGraphMol()
oechem.OEReadMolecule(oechem.oemolistream("complex.pdb"), complex)

# Prepare 2D depiction from 3D
oegrapheme.OEPrepareDepictionFrom3D(complex)

# Create complex surface arc function with different styles
arcfxn = oegrapheme.OEComplexSurfaceArcFxnBase()
arcfxn.SetBuriedArcFxn(oegrapheme.OEDefaultBuriedArcFxn())
arcfxn.SetSolventArcFxn(oegrapheme.OEDefaultSolventArcFxn())
oegrapheme.OEAddComplexSurfaceArcs(complex, arcfxn)

# Render
image = oedepict.OEImage(800, 600)
disp = oedepict.OE2DMolDisplay(complex)
oedepict.OERenderMolecule(image, disp)
oedepict.OEWriteImage("complex_surface.png", image)
```
Use when: Visualizing protein-ligand complexes with distinct surface styles for buried, solvent-exposed, and cavity regions

### Pattern: BFactor Property Map Visualization
```python
from openeye import oechem, oedepict, oegrapheme

# Read protein structure with BFactor data
protein = oechem.OEGraphMol()
oechem.OEReadMolecule(oechem.oemolistream("protein.pdb"), protein)

# Create and setup property map for BFactor
propmap = oegrapheme.OE2DPropMap(protein)
oegrapheme.OESetup2DPropMap(propmap, oegrapheme.OE2DPropMapSetup_BFactor)

# Render BFactor map
image = oedepict.OEImage(800, 600)
oegrapheme.OERenderBFactorMap(image, propmap)
oegrapheme.OEDrawBFactorMapLegend(image, propmap)
oedepict.OEWriteImage("bfactor.png", image)
```
Use when: Visualizing temperature factors or flexibility in protein structures

### Pattern: Shape Overlap Visualization
```python
from openeye import oechem, oedepict, oegrapheme, oeshape

# Read reference and fit molecules
refmol = oechem.OEGraphMol()
fitmol = oechem.OEGraphMol()
oechem.OEReadMolecule(oechem.oemolistream("ref.sdf"), refmol)
oechem.OEReadMolecule(oechem.oemolistream("fit.sdf"), fitmol)

# Prepare aligned depiction
oegrapheme.OEPrepareAlignedDepictionFrom3D(refmol, fitmol)

# Create shape overlap display
opts = oegrapheme.OEShapeOverlapDisplayOptions()
display = oegrapheme.OEShapeOverlapDisplay(refmol, fitmol, opts)

# Render with scores
image = oedepict.OEImage(800, 400)
oegrapheme.OERenderShapeOverlap(image, display)
oegrapheme.OEDrawROCSScores(image, refmol, fitmol)
oedepict.OEWriteImage("overlap.png", image)
```
Use when: Comparing molecular shapes and visualizing ROCS overlap results

### Pattern: Adding Atom and Bond Glyphs
```python
from openeye import oechem, oedepict, oegrapheme

# Create molecule
mol = oechem.OEGraphMol()
oechem.OESmilesToMol(mol, "c1ccccc1C(=O)O")
oedepict.OEPrepareDepiction(mol)

# Create display and add glyphs
image = oedepict.OEImage(400, 400)
disp = oedepict.OE2DMolDisplay(mol)

# Add circle glyph to specific atom
for atom in mol.GetAtoms():
    if atom.GetAtomicNum() == oechem.OEElemNo_O:
        glyph = oegrapheme.OEAtomGlyphCircle(oechem.OERedPen, 1.5)
        oegrapheme.OEAddGlyph(disp, glyph, atom)

oedepict.OERenderMolecule(image, disp)
oedepict.OEWriteImage("glyphs.png", image)
```
Use when: Highlighting specific atoms or bonds with visual markers

### Pattern: Peptide Sequence Visualization
```python
from openeye import oechem, oedepict, oegrapheme

# Read peptide structure
peptide = oechem.OEGraphMol()
oechem.OEReadMolecule(oechem.oemolistream("peptide.pdb"), peptide)

# Configure peptide display options
opts = oegrapheme.OEPeptideDisplayOptions()
opts.SetLabelStyle(oegrapheme.OEPeptideLabelStyle_ThreeLetter)

# Draw peptide
image = oedepict.OEImage(1200, 400)
oegrapheme.OEDrawPeptide(image, peptide, opts)
oedepict.OEWriteImage("peptide.png", image)
```
Use when: Visualizing peptide sequences with residue labels

### Pattern: Contact Map Visualization
```python
from openeye import oechem, oedepict, oegrapheme

# Read protein-ligand complex
complex = oechem.OEGraphMol()
oechem.OEReadMolecule(oechem.oemolistream("complex.pdb"), complex)

# Create contact map
propmap = oegrapheme.OE2DPropMap(complex)
oegrapheme.OESetup2DPropMap(propmap, oegrapheme.OE2DPropMapSetup_Contact)

# Render contact map
image = oedepict.OEImage(800, 600)
oegrapheme.OERenderContactMap(image, propmap)
oedepict.OEWriteImage("contacts.png", image)
```
Use when: Visualizing protein-ligand contact patterns and interaction frequencies

### Pattern: Interactive SVG with Residue Lookup
```python
from openeye import oechem, oedepict, oegrapheme

# Prepare active site display
protein = oechem.OEGraphMol()
oechem.OEReadMolecule(oechem.oemolistream("complex.pdb"), protein)
asite = oechem.OEInteractionHintContainer(protein, oechem.OEIsLigand())
adisp = oegrapheme.OEPrepareActiveSiteDepiction(asite)

# Render to SVG with markup
image = oedepict.OEImage(800, 600)
oegrapheme.OERenderActiveSite(image, adisp)
markup = oegrapheme.OEResidueSVGStandardMarkup()
oedepict.OEWriteImage("interactive.svg", image)

# Later, find residue at coordinates (e.g., from mouse click)
nearest = oegrapheme.OEGetNearestResidue(adisp, 400.0, 300.0)
if nearest.IsValid():
    residue = nearest.GetResidue()
```
Use when: Creating interactive SVG visualizations where users can click on residues

### Pattern: Color Force Field Overlap
```python
from openeye import oechem, oedepict, oegrapheme

# Read molecules with color atoms
refmol = oechem.OEGraphMol()
fitmol = oechem.OEGraphMol()
oechem.OEReadMolecule(oechem.oemolistream("ref.oeb"), refmol)
oechem.OEReadMolecule(oechem.oemolistream("fit.oeb"), fitmol)

# Configure color overlap display
opts = oegrapheme.OEColorOverlapDisplayOptions()
opts.SetRefMol(refmol)
opts.SetFitMol(fitmol)

# Render color overlap
image = oedepict.OEImage(800, 400)
oegrapheme.OERenderColorOverlap(image, opts)
oegrapheme.OEDrawColorForceFieldLegend(image, opts)
oedepict.OEWriteImage("color_overlap.png", image)
```
Use when: Visualizing color force field overlap between molecules (e.g., from ROCS)

### Pattern: Ramachandran Plot for Structure Validation
```python
from openeye import oechem, oedepict, oegrapheme

# Read protein structure
protein = oechem.OEGraphMol()
oechem.OEReadMolecule(oechem.oemolistream("protein.pdb"), protein)

# Create Ramachandran plot
plot = oegrapheme.OERamachandranPlot(protein)

# Add markers for specific residues
for residue in oechem.OEGetResidues(protein):
    phi = oechem.OEGetTorsion(residue, oechem.OETorsionType_Phi)
    psi = oechem.OEGetTorsion(residue, oechem.OETorsionType_Psi)
    marker = oegrapheme.OEPlotMarker(phi, psi)
    plot.AddMarker(marker)

# Render plot
image = oedepict.OEImage(600, 600)
oegrapheme.OERenderRamachandranPlot(image, plot)
oedepict.OEWriteImage("ramachandran.png", image)
```
Use when: Validating protein structure quality by analyzing backbone dihedral angles

### Pattern: Custom Arc Functions for Different Surface Regions
```python
from openeye import oechem, oedepict, oegrapheme

# Create molecule
mol = oechem.OEGraphMol()
oechem.OESmilesToMol(mol, "c1ccccc1CCO")
oedepict.OEPrepareDepiction(mol)

# Get surface arcs and draw with custom functions
image = oedepict.OEImage(400, 400)
disp = oedepict.OE2DMolDisplay(mol)

for arc in oegrapheme.OEGet2DSurfaceArcs(mol):
    # Use different arc styles based on arc properties
    if arc.GetAngle() > 180.0:
        arcfxn = oegrapheme.OEPearlsArcFxn(oechem.OEBluePen)
    else:
        arcfxn = oegrapheme.OEDefaultArcFxn(oechem.OEBlackPen)
    oegrapheme.OEDrawSurfaceArc(image, arc, arcfxn)

oedepict.OERenderMolecule(image, disp)
oedepict.OEWriteImage("custom_arcs.png", image)
```
Use when: You need fine-grained control over surface arc appearance based on geometric properties

## API Decision Guide

### Visualization Type Selection
- For **protein-ligand interactions**: use `OERenderActiveSite` with `OE2DActiveSiteDisplay`
- For **molecular surfaces**: use `OEDraw2DSurface` for simple surfaces, `OEAddComplexSurfaceArcs` for protein-ligand complexes
- For **shape comparison**: use `OERenderShapeOverlap` with `OEShapeOverlapDisplay`
- For **property mapping**: use `OERenderBFactorMap` or `OERenderContactMap` with `OE2DPropMap`
- For **peptide sequences**: use `OEDrawPeptide` with `OEPeptideDisplayOptions`
- For **structure validation**: use `OERenderRamachandranPlot` with `OERamachandranPlot`

### 3D to 2D Conversion
- For **single molecule**: use `OEPrepareDepictionFrom3D` to convert 3D coordinates to 2D layout
- For **aligned comparison**: use `OEPrepareAlignedDepictionFrom3D` to align two molecules in 2D based on 3D overlay
- For **active sites**: use `OEPrepareActiveSiteDepiction` which handles 3D to 2D conversion automatically

### Surface Arc Customization
- For **default styling**: use `OEDraw2DSurface` without custom arc functions
- For **custom colors/styles**: use `OESetSurfaceArcFxn` with arc function classes (e.g., `OEDefaultArcFxn`, `OEPearlsArcFxn`)
- For **complex surfaces**: use `OEAddComplexSurfaceArcs` with `OEComplexSurfaceArcFxnBase` to style buried/solvent/cavity regions differently
- For **manual control**: use `OEGet2DSurfaceArcs` to iterate arcs and `OEDrawSurfaceArc` to draw each individually

### Annotation and Highlighting
- For **atom markers**: use `OEAddGlyph` with `OEAtomGlyphCircle` or custom `OEAtomGlyphBase`
- For **bond markers**: use `OEAddGlyph` with `OEBondGlyphArrow`, `OEBondGlyphScissors`, etc.
- For **ligand highlighting**: use `OEAddLigandHighlighting` on `OE2DActiveSiteDisplay`
- For **residue highlighting**: use `OEAddResidueHighlighting` on `OE2DActiveSiteDisplay`

### Interactive Features
- For **finding residues**: use `OEGetNearestResidue` or `OEGetNearbyResidue` with coordinates
- For **finding atoms**: use `OEGetNearestAtom` or `OEGetNearbyAtom` with coordinates
- For **SVG markup**: use `OEResidueSVGStandardMarkup` when rendering to SVG format

### Property Map Setup
- For **B-factors**: use `OESetup2DPropMap` with `OE2DPropMapSetup_BFactor`
- For **contacts**: use `OESetup2DPropMap` with `OE2DPropMapSetup_Contact`
- For **custom properties**: use `OEConfigure2DPropMap` with custom configuration

## Common Parameters & Types

**OE2DActiveSiteDisplayOptions**: Configuration for active site rendering
  - Create with: `opts = oegrapheme.OE2DActiveSiteDisplayOptions()`
  - Common in: `OERenderActiveSite`, `OEPrepareActiveSiteDepiction`, `OE2DActiveSiteDisplay`
  - Key methods: `SetRenderStyle()`, `SetWidth()`, `SetHeight()`
  - Gotcha: Must be configured before passing to `OEPrepareActiveSiteDepiction` for proper layout

**OESurfaceArcFxnBase**: Base class for surface arc drawing functions
  - Create with: Use derived classes like `OEDefaultArcFxn(pen)`, `OEPearlsArcFxn(pen)`, `OEStitchArcFxn(pen)`
  - Common in: `OESetSurfaceArcFxn`, `OEDrawSurfaceArc`, `OEGet2DSurfaceArcs`
  - Typical values: `OEDefaultArcFxn`, `OEPearlsArcFxn`, `OECogArcFxn`, `OEFlowerArcFxn`
  - Gotcha: Different arc functions create dramatically different visual styles; preview before choosing

**OE2DPropMap**: Property map for visualizing molecular properties
  - Create with: `propmap = oegrapheme.OE2DPropMap(mol)`
  - Common in: `OERenderBFactorMap`, `OERenderContactMap`, `OESetup2DPropMap`
  - Setup with: `OESetup2DPropMap(propmap, OE2DPropMapSetup_BFactor)` or similar
  - Gotcha: Must call setup function before rendering; different setups require different input data

**OEShapeOverlapDisplayOptions**: Configuration for shape overlap visualization
  - Create with: `opts = oegrapheme.OEShapeOverlapDisplayOptions()`
  - Common in: `OEShapeOverlapDisplay`, `OERenderShapeOverlap`
  - Key methods: `SetDisplayStyle()`, `SetColorAtomStyle()`
  - Typical values: Display styles include `OEShapeOverlapDisplayStyle_ColorAtoms`, `OEShapeOverlapDisplayStyle_Grid`

**OEAtomGlyphBase / OEBondGlyphBase**: Visual markers for atoms and bonds
  - Create with