Stereonet 2D Demo

Comprehensive demonstration of Stereonet2D functionality in Dips Python API.

This script demonstrates Stereonet2D services including: - View Management: Create, Get, Close views - Entity Visibility: Poles, Intersections, Contours, Kinematic Analysis, Global Planes, Overlay - Entity Options: Pole options, Symbolic settings, Intersection options, Contour settings - Kinematic Analysis: Settings and visibility - Group Visibility: Sets, Planes, Traverses, Folds - Legend and Display Settings: Weighted, VectorMode, ProjectionMode - Entity References: Get and set individual entity visibility/options - Data Filters: Get and set active filter

Note: Tool demonstrations are in Stereonet2DToolsDemo.py

Code Snippet: Stereonet2DDemo.py

"""
Comprehensive demonstration of Stereonet2D functionality in Dips Python API.

This script demonstrates Stereonet2D services including:
- View Management: Create, Get, Close views
- Entity Visibility: Poles, Intersections, Contours, Kinematic Analysis, Global Planes, Overlay
- Entity Options: Pole options, Symbolic settings, Intersection options, Contour settings
- Kinematic Analysis: Settings and visibility
- Group Visibility: Sets, Planes, Traverses, Folds
- Legend and Display Settings: Weighted, VectorMode, ProjectionMode
- Entity References: Get and set individual entity visibility/options
- Data Filters: Get and set active filter

Note: Tool demonstrations are in Stereonet2DToolsDemo.py
"""

import math
from dips import DipsApp, BuiltInDataFormatters

# Helper value wrappers
from dips.TrendPlungeVal import TrendPlungeVal
from dips.ColorSurrogateVal import ColorSurrogateVal

# Entity options and visibility wrappers
from dips.PoleEntityOptionsVal import PoleEntityOptionsVal
from dips.ContourEntityVisibilityVal import ContourEntityVisibilityVal
from dips.GlobalPlaneEntityVisibilityVal import GlobalPlaneEntityVisibilityVal
from dips.StereonetOverlayEntityVisibilityVal import StereonetOverlayEntityVisibilityVal
from dips.StereonetOverlaySettingsVal import StereonetOverlaySettingsVal
from dips.KinematicAnalysisEntityVisibilityVal import KinematicAnalysisEntityVisibilityVal
from dips.SetVersusSetVal import SetVersusSetVal
from dips.SetEntityOptionsVal import SetEntityOptionsVal
from dips.UserPlaneEntityOptionsVal import UserPlaneEntityOptionsVal
from dips.TraverseEntityOptionsVal import TraverseEntityOptionsVal
from dips.FoldEntityOptionsVal import FoldEntityOptionsVal

# Data wrappers
from dips.DiscontinuityDataVal import DiscontinuityDataVal

# =============================================================================
# SAMPLE DATA CREATION
# =============================================================================

def create_sample_traverse_with_poles(model):
    """Create a sample traverse with discontinuities (poles) for demonstration."""
    ods = model.GetDefaultOrientationDataSet()
    ods.name = "Sample Traverse for Stereonet2D Demo"
    ods.orientation_convention = DipsApp.enums.eOrientationConvention.TrendPlungeOrientation
    ods.orientation_data_type = DipsApp.enums.eOrientationDataType.SpotMapping
    ods.discontinuity_orientation_convention = DipsApp.enums.eOrientationConvention.TrendPlungeOrientation
    
    # Use built-in unit formatters
    ods.traverse_elevation_unit = BuiltInDataFormatters.LengthMeterDataFormatter
    ods.traverse_xyz_unit = BuiltInDataFormatters.LengthMeterDataFormatter
    ods.traverse_depth_unit = BuiltInDataFormatters.LengthMeterDataFormatter
    ods.survey_distance_unit = BuiltInDataFormatters.LengthMeterDataFormatter
    ods.discontinuity_distance_unit = BuiltInDataFormatters.LengthMeterDataFormatter
    ods.discontinuity_xyz_unit = BuiltInDataFormatters.LengthMeterDataFormatter
    ods.discontinuity_persistence_unit = BuiltInDataFormatters.LengthMeterDataFormatter
    
    # Create sample poles with different orientations
    sample_poles = [
        (45, 30), (90, 45), (135, 60), (180, 30),
        (225, 45), (270, 60), (315, 30), (0, 45),
        (60, 75), (120, 25), (240, 50), (300, 40),
    ]
    
    for trend_deg, plunge_deg in sample_poles:
        discontinuity = DiscontinuityDataVal()
        discontinuity.orientation1.angle_radians = math.radians(trend_deg)
        discontinuity.orientation2.angle_radians = math.radians(plunge_deg)
        discontinuity.quantity = 1.0
        ods.discontinuity_list.append(discontinuity)
    
    return ods


# =============================================================================
# VIEW MANAGEMENT DEMONSTRATIONS
# =============================================================================

def demonstrate_view_management(model):
    """Demonstrate view creation and listing."""
    print("\n" + "=" * 60)
    print("VIEW MANAGEMENT")
    print("=" * 60)
    
    # Get existing views
    views = model.GetStereonet2DViewList()
    print(f"  Found {len(views)} existing Stereonet2D view(s)")
    
    # Create a new view
    print("  Creating new Stereonet2D view...")
    new_view = model.CreateStereonet2DView()
    view_value = new_view.GetValue()
    print(f"  ✓ Created view: '{view_value.view_name}'")
    
    return new_view


# =============================================================================
# ENTITY VISIBILITY DEMONSTRATIONS
# =============================================================================

def demonstrate_entity_visibility(view):
    """Demonstrate all entity visibility settings."""
    print("\n" + "=" * 60)
    print("ENTITY VISIBILITY")
    print("=" * 60)
    
    view.SetPoleEntityVisibility(True)
    print("  ✓ SetPoleEntityVisibility: True")
    
    view.SetIntersectionEntityVisibility(True)
    print("  ✓ SetIntersectionEntityVisibility: True")
    
    view.SetContourEntityVisibility(True)
    print("  ✓ SetContourEntityVisibility: True")
    
    view.SetKinematicAnalysisEntityVisibility(True)
    print("  ✓ SetKinematicAnalysisEntityVisibility: True")
    
    view.SetGlobalMeanPlaneEntityVisibility(True)
    print("  ✓ SetGlobalMeanPlaneEntityVisibility: True")
    
    view.SetGlobalBestFitPlaneEntityVisibility(True)
    print("  ✓ SetGlobalBestFitPlaneEntityVisibility: True")
    
    view.SetStereonetOverlayEntityVisibility(True)
    print("  ✓ SetStereonetOverlayEntityVisibility: True")


# =============================================================================
# ENTITY OPTIONS DEMONSTRATIONS
# =============================================================================

def demonstrate_pole_options(view, model):
    """Demonstrate pole entity options and symbolic settings."""
    print("\n" + "=" * 60)
    print("POLE OPTIONS")
    print("=" * 60)
    
    # Pole entity options
    pole_options = PoleEntityOptionsVal()
    pole_options.pole_mode = DipsApp.enums.ePoleMode.Vector
    pole_options.show_pole_planes = False
    pole_options.show_pole_vector_lines = True
    view.SetPoleEntityOptions(pole_options)
    print("  ✓ SetPoleEntityOptions (Vector mode)")
    
    # Symbolic settings
    symbolic = model.GetDefaultSymbolicSettings()
    view.SetSymbolicSettings(symbolic)
    print("  ✓ SetSymbolicSettings")


def demonstrate_intersection_options(view, model):
    """Demonstrate intersection entity options."""
    print("\n" + "=" * 60)
    print("INTERSECTION OPTIONS")
    print("=" * 60)
    
    # Intersection entity options - use GetDefault
    intersection_options = model.GetDefaultIntersectionOptions()
    view.SetIntersectionEntityOptions(intersection_options)
    print("  ✓ SetIntersectionEntityOptions")
    
    # Intersection type
    view.SetIntersectionType(DipsApp.enums.eIntersectionType.AllPoleIntersections)
    print("  ✓ SetIntersectionType (AllPoleIntersections)")
    
    # Set versus set (requires two sets to exist)
    sets = model.GetSetList()
    if len(sets) >= 2:
        set_vs_set = SetVersusSetVal()
        set_vs_set.set_a = sets[0]
        set_vs_set.set_b = sets[1]
        view.SetSetVersusSet(set_vs_set)
        print("  ✓ SetSetVersusSet")
    else:
        print("  - SetSetVersusSet (needs 2+ sets)")


def demonstrate_contour_options(view, model):
    """Demonstrate contour entity options and settings."""
    print("\n" + "=" * 60)
    print("CONTOUR OPTIONS")
    print("=" * 60)
    
    # Contour entity options (no GetDefault available, use manual)
    contour_visibility = ContourEntityVisibilityVal()
    contour_visibility.is_visible = True
    view.SetContourEntityOptions(contour_visibility)
    print("  ✓ SetContourEntityOptions")
    
    # Contour type
    view.SetContourType(DipsApp.enums.eContourType.PoleVectorDensity)
    print("  ✓ SetContourType (PoleVectorDensity)")
    
    # Pole vector density contour settings - use GetDefault
    density_settings = model.GetDefaultVectorDensityContourSettings()
    view.SetPoleVectorDensityContourSettings(density_settings)
    print("  ✓ SetPoleVectorDensityContourSettings")
    
    # Intersection vector density contour settings - use GetDefault
    density_settings = model.GetDefaultVectorDensityContourSettings()
    view.SetIntersectionVectorDensityContourSettings(density_settings)
    print("  ✓ SetIntersectionVectorDensityContourSettings")
    
    # Quantitative contour settings - use GetDefault
    quant_settings = model.GetDefaultQuantitativeContourSettings()
    view.SetQuantitativeContourSettings(quant_settings)
    print("  ✓ SetQuantitativeContourSettings")
    
    # Contour options for each type - use GetDefault
    contour_options = model.GetDefaultContourOptions()
    view.SetPoleVectorContourOptions(contour_options)
    print("  ✓ SetPoleVectorContourOptions")
    
    contour_options = model.GetDefaultContourOptions()
    view.SetIntersectionVectorContourOptions(contour_options)
    print("  ✓ SetIntersectionVectorContourOptions")
    
    contour_options = model.GetDefaultContourOptions()
    view.SetQuantitativeContourOptions(contour_options)
    print("  ✓ SetQuantitativeContourOptions")


def demonstrate_kinematic_analysis(view, model):
    """Demonstrate kinematic analysis options and settings."""
    print("\n" + "=" * 60)
    print("KINEMATIC ANALYSIS")
    print("=" * 60)
    
    # Kinematic analysis entity options (no GetDefault available, use manual)
    kinematic_visibility = KinematicAnalysisEntityVisibilityVal()
    kinematic_visibility.is_visible = True
    view.SetKinematicAnalysisEntityOptions(kinematic_visibility)
    print("  ✓ SetKinematicAnalysisEntityOptions")
    
    # Kinematic analysis settings - use GetDefault and modify
    kinematic_settings = model.GetDefaultKinematicAnalysisSettings()
    kinematic_settings.failure_mode_option = DipsApp.enums.eFailureModeOption.PlanarSliding
    kinematic_settings.slope_dip.angle_radians = math.radians(45)
    kinematic_settings.slope_dip_direction.angle_radians = math.radians(180)
    kinematic_settings.friction_angle.angle_radians = math.radians(30)
    view.SetKinematicAnalysisSettings(kinematic_settings)
    print("  ✓ SetKinematicAnalysisSettings (Planar Sliding)")


def demonstrate_global_plane_options(view):
    """Demonstrate global plane options."""
    print("\n" + "=" * 60)
    print("GLOBAL PLANE OPTIONS")
    print("=" * 60)
    
    # Global mean plane
    global_mean = GlobalPlaneEntityVisibilityVal()
    global_mean.is_visible = True
    view.SetGlobalMeanPlaneEntityOptions(global_mean)
    print("  ✓ SetGlobalMeanPlaneEntityOptions")
    
    # Global best fit plane
    global_best_fit = GlobalPlaneEntityVisibilityVal()
    global_best_fit.is_visible = True
    view.SetGlobalBestFitPlaneEntityOptions(global_best_fit)
    print("  ✓ SetGlobalBestFitPlaneEntityOptions")


def demonstrate_stereonet_overlay(view):
    """Demonstrate stereonet overlay options."""
    print("\n" + "=" * 60)
    print("STEREONET OVERLAY")
    print("=" * 60)
    
    # Polar overlay
    overlay_visibility = StereonetOverlayEntityVisibilityVal()
    overlay_visibility.is_visible = True
    overlay_settings = StereonetOverlaySettingsVal()
    overlay_settings.option = DipsApp.enums.eStereonetOverlayOption.Polar
    overlay_settings.color = ColorSurrogateVal.FromRGBA(128, 128, 128, 180)
    overlay_visibility.stereonet_overlay_settings = overlay_settings
    view.SetStereonetOverlayEntityOptions(overlay_visibility)
    print("  ✓ SetStereonetOverlayEntityOptions (Polar)")
    
    # Equatorial overlay
    overlay_visibility = StereonetOverlayEntityVisibilityVal()
    overlay_visibility.is_visible = True
    overlay_settings = StereonetOverlaySettingsVal()
    overlay_settings.option = DipsApp.enums.eStereonetOverlayOption.Equatorial
    overlay_settings.color = ColorSurrogateVal.FromRGBA(0, 0, 255)
    overlay_visibility.stereonet_overlay_settings = overlay_settings
    view.SetStereonetOverlayEntityOptions(overlay_visibility)
    print("  ✓ SetStereonetOverlayEntityOptions (Equatorial)")
    
    # Custom overlay
    overlay_visibility = StereonetOverlayEntityVisibilityVal()
    overlay_visibility.is_visible = True
    overlay_settings = StereonetOverlaySettingsVal()
    overlay_settings.option = DipsApp.enums.eStereonetOverlayOption.CustomOverlay
    overlay_settings.color = ColorSurrogateVal.FromRGBA(255, 0, 0)
    overlay_settings.custom_orientation = TrendPlungeVal.FromTrendPlunge(45, 60)
    overlay_visibility.stereonet_overlay_settings = overlay_settings
    view.SetStereonetOverlayEntityOptions(overlay_visibility)
    print("  ✓ SetStereonetOverlayEntityOptions (Custom)")


# =============================================================================
# GROUP VISIBILITY DEMONSTRATIONS
# =============================================================================

def demonstrate_group_visibility(view):
    """Demonstrate all group visibility settings."""
    print("\n" + "=" * 60)
    print("GROUP VISIBILITY")
    print("=" * 60)
    
    view.SetSetWindowEntityGroupVisibility(True)
    print("  ✓ SetSetWindowEntityGroupVisibility: True")
    
    view.SetMeanSetPlaneEntityGroupVisibility(True)
    print("  ✓ SetMeanSetPlaneEntityGroupVisibility: True")
    
    view.SetUserPlaneEntityGroupVisibility(True)
    print("  ✓ SetUserPlaneEntityGroupVisibility: True")
    
    view.SetTraverseEntityGroupVisibility(True)
    print("  ✓ SetTraverseEntityGroupVisibility: True")
    
    view.SetFoldWindowEntityGroupVisibility(True)
    print("  ✓ SetFoldWindowEntityGroupVisibility: True")
    
    view.SetBestFitFoldPlaneEntityGroupVisibility(True)
    print("  ✓ SetBestFitFoldPlaneEntityGroupVisibility: True")


# =============================================================================
# LEGEND AND DISPLAY SETTINGS
# =============================================================================

def demonstrate_legend_and_settings(view, model):
    """Demonstrate legend and display settings."""
    print("\n" + "=" * 60)
    print("LEGEND AND DISPLAY SETTINGS")
    print("=" * 60)
    
    # Legend visibility
    view.SetLegendVisibility(True)
    print("  ✓ SetLegendVisibility: True")
    
    # IsWeighted
    view.SetIsWeighted(False)
    print("  ✓ SetIsWeighted: False")
    
    # VectorMode
    view.SetVectorMode(DipsApp.enums.eVectorMode.Pole)
    print("  ✓ SetVectorMode: Pole")
    
    # ProjectionMode - use GetDefault and modify
    projection = model.GetDefaultStereonetProjectionMode()
    projection.hemisphere_draw_option = DipsApp.enums.eHemisphereDrawOption.Lower
    projection.projection_method_draw_option = DipsApp.enums.eProjectionMethodDrawOption.EqualArea
    view.SetProjectionMode(projection)
    print("  ✓ SetProjectionMode: Lower Hemisphere, EqualArea")


# =============================================================================
# ENTITY REFERENCE DEMONSTRATIONS
# =============================================================================

def demonstrate_entity_references(view):
    """Demonstrate getting and setting entity references."""
    print("\n" + "=" * 60)
    print("ENTITY REFERENCES")
    print("=" * 60)
    
    entities = view.GetSetWindowEntityVisibilityList()
    print(f"  ✓ GetSetWindowEntityVisibilityList: {len(entities)} found")
    
    entities = view.GetMeanSetPlaneEntityVisibilityList()
    print(f"  ✓ GetMeanSetPlaneEntityVisibilityList: {len(entities)} found")
    
    entities = view.GetUserPlaneEntityVisibilityList()
    print(f"  ✓ GetUserPlaneEntityVisibilityList: {len(entities)} found")
    
    entities = view.GetTraverseEntityVisibilityList()
    print(f"  ✓ GetTraverseEntityVisibilityList: {len(entities)} found")
    
    entities = view.GetFoldWindowEntityVisibilityList()
    print(f"  ✓ GetFoldWindowEntityVisibilityList: {len(entities)} found")
    
    entities = view.GetBestFitFoldPlaneEntityVisibilityList()
    print(f"  ✓ GetBestFitFoldPlaneEntityVisibilityList: {len(entities)} found")


def demonstrate_individual_entity_visibility(view):
    """Demonstrate setting visibility and options for individual entities."""
    print("\n" + "=" * 60)
    print("INDIVIDUAL ENTITY VISIBILITY/OPTIONS")
    print("=" * 60)
    
    # Set Window entities
    entities = view.GetSetWindowEntityVisibilityList()
    if entities:
        entities[0].SetStereonet2DSetWindowEntityVisibility(True)
        print(f"  ✓ SetStereonet2DSetWindowEntityVisibility: True")
    else:
        print("  - SetStereonet2DSetWindowEntityVisibility: No set windows available")
    
    # Mean Set Plane entities
    entities = view.GetMeanSetPlaneEntityVisibilityList()
    if entities:
        entities[0].SetStereonet2DMeanSetPlaneEntityVisibility(True)
        print(f"  ✓ SetStereonet2DMeanSetPlaneEntityVisibility: True")
        # Also demonstrate SetStereonet2DMeanSetPlaneEntityOptions
        opts = SetEntityOptionsVal()
        opts.show_label = True
        entities[0].SetStereonet2DMeanSetPlaneEntityOptions(opts)
        print(f"  ✓ SetStereonet2DMeanSetPlaneEntityOptions")
    else:
        print("  - SetStereonet2DMeanSetPlaneEntityVisibility: No mean set planes available")
    
    # User Plane entities
    entities = view.GetUserPlaneEntityVisibilityList()
    if entities:
        entities[0].SetStereonet2DUserPlaneEntityVisibility(True)
        print(f"  ✓ SetStereonet2DUserPlaneEntityVisibility: True")
        # Also demonstrate SetStereonet2DUserPlaneEntityOptions
        opts = UserPlaneEntityOptionsVal()
        opts.show_label = True
        entities[0].SetStereonet2DUserPlaneEntityOptions(opts)
        print(f"  ✓ SetStereonet2DUserPlaneEntityOptions")
    else:
        print("  - SetStereonet2DUserPlaneEntityVisibility: No user planes available")
    
    # Traverse entities
    entities = view.GetTraverseEntityVisibilityList()
    if entities:
        entities[0].SetStereonet2DTraverseEntityVisibility(True)
        print(f"  ✓ SetStereonet2DTraverseEntityVisibility: True")
        # Also demonstrate SetStereonet2DTraverseEntityOptions
        opts = TraverseEntityOptionsVal()
        opts.show_label = True
        entities[0].SetStereonet2DTraverseEntityOptions(opts)
        print(f"  ✓ SetStereonet2DTraverseEntityOptions")
    else:
        print("  - SetStereonet2DTraverseEntityVisibility: No traverses available")
    
    # Fold Window entities
    entities = view.GetFoldWindowEntityVisibilityList()
    if entities:
        entities[0].SetStereonet2DFoldWindowEntityVisibility(True)
        print(f"  ✓ SetStereonet2DFoldWindowEntityVisibility: True")
    else:
        print("  - SetStereonet2DFoldWindowEntityVisibility: No fold windows available")
    
    # Fold entities (best fit fold planes)
    entities = view.GetBestFitFoldPlaneEntityVisibilityList()
    if entities:
        entities[0].SetStereonet2DFoldEntityVisibility(True)
        print(f"  ✓ SetStereonet2DFoldEntityVisibility: True")
        # Also demonstrate SetStereonet2DFoldEntityOptions
        opts = FoldEntityOptionsVal()
        opts.show_label = True
        entities[0].SetStereonet2DFoldEntityOptions(opts)
        print(f"  ✓ SetStereonet2DFoldEntityOptions")
    else:
        print("  - SetStereonet2DFoldEntityVisibility: No fold entities available")


# =============================================================================
# DATA FILTER DEMONSTRATIONS
# =============================================================================

def demonstrate_active_data_filter(view, model):
    """Demonstrate active data filter management."""
    print("\n" + "=" * 60)
    print("ACTIVE DATA FILTER")
    print("=" * 60)
    
    # Get current active filter
    active_filter = view.GetActiveDataFilter()
    if active_filter:
        filter_value = active_filter.GetValue()
        print(f"  ✓ GetActiveDataFilter: '{filter_value.name}'")
    else:
        print("  ✓ GetActiveDataFilter: None (no active filter)")
    
    # Set active filter (if filters exist)
    filters = model.GetDataFilterList()
    if filters:
        view.SetActiveDataFilter(filters[0])
        filter_value = filters[0].GetValue()
        print(f"  ✓ SetActiveDataFilter: '{filter_value.name}'")
    else:
        print("  - SetActiveDataFilter: No filters available")


# =============================================================================
# VIEW CLOSE DEMONSTRATION
# =============================================================================

def demonstrate_close_view(view):
    """Demonstrate closing a view."""
    print("\n" + "=" * 60)
    print("CLOSE VIEW")
    print("=" * 60)
    
    view_value = view.GetValue()
    view_name = view_value.view_name
    view.CloseStereonet2DView()
    print(f"  ✓ CloseStereonet2DView: '{view_name}'")


# =============================================================================
# MAIN
# =============================================================================

def main():
    """Main demonstration function."""
    print("=" * 60)
    print("Dips API - Stereonet2D Comprehensive Demo")
    print("=" * 60)
    
    # Connect to Dips
    print("\nConnecting to Dips application...")
    app = DipsApp.LaunchApp(62535)
    print("✓ Connected to Dips")
    
    model = app.GetModel()
    
    # Create sample data if needed
    print("\n" + "-" * 60)
    print("SAMPLE DATA SETUP")
    print("-" * 60)
    traverses = model.GetTraverseList()
    if len(traverses) == 0:
        print("Creating sample traverse with poles...")
        ods = create_sample_traverse_with_poles(model)
        model.AddTraverse(ods)
        print(f"  ✓ Created traverse with {len(ods.discontinuity_list)} poles")
    else:
        print(f"  ✓ Found {len(traverses)} existing traverse(s)")
    
    # Get or create a view
    views = model.GetStereonet2DViewList()
    if views:
        view = views[0]
        print(f"  Using existing view: '{view.GetValue().view_name}'")
    else:
        view = demonstrate_view_management(model)
    
    # Run all demonstrations
    demonstrate_entity_visibility(view)
    demonstrate_pole_options(view, model)
    demonstrate_intersection_options(view, model)
    demonstrate_contour_options(view, model)
    demonstrate_kinematic_analysis(view, model)
    demonstrate_global_plane_options(view)
    demonstrate_stereonet_overlay(view)
    demonstrate_group_visibility(view)
    demonstrate_legend_and_settings(view, model)
    demonstrate_entity_references(view)
    demonstrate_individual_entity_visibility(view)
    demonstrate_active_data_filter(view, model)
    
    # Create and close a new view to demonstrate view lifecycle
    print("\n" + "-" * 60)
    print("VIEW LIFECYCLE DEMO")
    print("-" * 60)
    new_view = model.CreateStereonet2DView()
    print(f"  ✓ Created new view: '{new_view.GetValue().view_name}'")
    demonstrate_close_view(new_view)
    
    # Show the application
    print("\n" + "-" * 60)
    app.Show()
    
    # Summary
    print("\n" + "=" * 60)
    print("DEMONSTRATION COMPLETE")
    print("=" * 60)
    print("""
Stereonet2D services demonstrated (56 methods):

VIEW MANAGEMENT (3 methods):
  - GetStereonet2DViewList
  - CreateStereonet2DView
  - CloseStereonet2DView

ENTITY VISIBILITY (7 methods):
  - SetPoleEntityVisibility
  - SetIntersectionEntityVisibility
  - SetContourEntityVisibility
  - SetKinematicAnalysisEntityVisibility
  - SetGlobalMeanPlaneEntityVisibility
  - SetGlobalBestFitPlaneEntityVisibility
  - SetStereonetOverlayEntityVisibility

ENTITY OPTIONS (18 methods):
  - SetPoleEntityOptions
  - SetSymbolicSettings
  - SetIntersectionEntityOptions
  - SetIntersectionType
  - SetSetVersusSet
  - SetContourEntityOptions
  - SetContourType
  - SetPoleVectorDensityContourSettings
  - SetIntersectionVectorDensityContourSettings
  - SetQuantitativeContourSettings
  - SetPoleVectorContourOptions
  - SetIntersectionVectorContourOptions
  - SetQuantitativeContourOptions
  - SetKinematicAnalysisEntityOptions
  - SetKinematicAnalysisSettings
  - SetGlobalMeanPlaneEntityOptions
  - SetGlobalBestFitPlaneEntityOptions
  - SetStereonetOverlayEntityOptions

GROUP VISIBILITY (6 methods):
  - SetSetWindowEntityGroupVisibility
  - SetMeanSetPlaneEntityGroupVisibility
  - SetUserPlaneEntityGroupVisibility
  - SetTraverseEntityGroupVisibility
  - SetFoldWindowEntityGroupVisibility
  - SetBestFitFoldPlaneEntityGroupVisibility

LEGEND AND SETTINGS (4 methods):
  - SetLegendVisibility
  - SetIsWeighted
  - SetVectorMode
  - SetProjectionMode

ENTITY REFERENCE LISTS (6 methods):
  - GetSetWindowEntityVisibilityList
  - GetMeanSetPlaneEntityVisibilityList
  - GetUserPlaneEntityVisibilityList
  - GetTraverseEntityVisibilityList
  - GetFoldWindowEntityVisibilityList
  - GetBestFitFoldPlaneEntityVisibilityList

INDIVIDUAL ENTITY VISIBILITY/OPTIONS (10 methods):
  - SetStereonet2DSetWindowEntityVisibility
  - SetStereonet2DMeanSetPlaneEntityVisibility
  - SetStereonet2DMeanSetPlaneEntityOptions
  - SetStereonet2DUserPlaneEntityVisibility
  - SetStereonet2DUserPlaneEntityOptions
  - SetStereonet2DTraverseEntityVisibility
  - SetStereonet2DTraverseEntityOptions
  - SetStereonet2DFoldWindowEntityVisibility
  - SetStereonet2DFoldEntityVisibility
  - SetStereonet2DFoldEntityOptions

DATA FILTER (2 methods):
  - GetActiveDataFilter
  - SetActiveDataFilter
""")


if __name__ == "__main__":
    main()