Python Scripting for Advanced CAD Design

>>> exec(open('/path/to/script.py').read())

import Part
import FreeCAD as App
import math

def create_involute_gear(module, num_teeth, pressure_angle=20, thickness=10):
    """
    Generate a parametric involute spur gear.

    Parameters:
    - module: Gear module (pitch diameter / number of teeth) in mm
    - num_teeth: Number of teeth
    - pressure_angle: Pressure angle in degrees (typically 20°)
    - thickness: Gear thickness in mm

    Returns: FreeCAD Part object
    """

    # Calculate gear geometry
    pitch_diameter = module * num_teeth
    pitch_radius = pitch_diameter / 2.0

    pressure_angle_rad = math.radians(pressure_angle)
    base_radius = pitch_radius * math.cos(pressure_angle_rad)
    addendum = module  # Height above pitch circle
    dedendum = 1.25 * module  # Depth below pitch circle
    outer_radius = pitch_radius + addendum
    root_radius = pitch_radius - dedendum

    # Angular tooth spacing
    tooth_angle = 2 * math.pi / num_teeth

    # Generate one tooth profile
    def involute_point(theta):
        """Generate point on involute curve"""
        x = base_radius * (math.cos(theta) + theta * math.sin(theta))
        y = base_radius * (math.sin(theta) - theta * math.cos(theta))
        return (x, y)

    # Build complete gear
    teeth_wires = []

    for tooth_num in range(num_teeth):
        angle_offset = tooth_num * tooth_angle

        # Generate involute curve points (from base circle to outer)
        involute_points = []
        theta_start = 0
        theta_end = math.sqrt((outer_radius / base_radius)**2 - 1)

        for i in range(20):  # 20 points per involute curve
            theta = theta_start + (theta_end - theta_start) * i / 19.0
            x, y = involute_point(theta)

            # Rotate to tooth position
            x_rot = x * math.cos(angle_offset) - y * math.sin(angle_offset)
            y_rot = x * math.sin(angle_offset) + y * math.cos(angle_offset)

            involute_points.append(App.Vector(x_rot, y_rot, 0))

        # Create tooth profile wire
        # (Simplified - real implementation would include root fillet, mirror, etc.)
        tooth_curve = Part.BSplineCurve()
        tooth_curve.interpolate(involute_points)
        teeth_wires.append(tooth_curve.toShape())

    # Create gear body (simplified - circular approximation)
    # In production code, would build precise tooth profiles
    gear_circle = Part.makeCircle(pitch_radius)
    gear_face = Part.Face(Part.Wire(gear_circle))
    gear_solid = gear_face.extrude(App.Vector(0, 0, thickness))

    return gear_solid

# Generate gear
gear = create_involute_gear(module=2.5, num_teeth=24, thickness=10)
Part.show(gear, "InvoluteGear")

print("✓ Involute gear generated!")
print(f"  Pitch diameter: {2.5 * 24} mm")
print(f"  Number of teeth: 24")

# Small gear - Module 2, 18 teeth
gear_small = create_involute_gear(module=2.0, num_teeth=18, thickness=8)
Part.show(gear_small, "SmallGear")

# Large gear - Module 3, 48 teeth
gear_large = create_involute_gear(module=3.0, num_teeth=48, thickness=12)
Part.show(gear_large, "LargeGear")

# Fine pitch gear - Module 1.5, 30 teeth
gear_fine = create_involute_gear(module=1.5, num_teeth=30, thickness=6)
Part.show(gear_fine, "FinePitchGear")

# Generate family of gears for testing
for teeth in [12, 18, 24, 30, 36]:
    gear = create_involute_gear(module=2.5, num_teeth=teeth, thickness=10)
    Part.show(gear, f"Gear_{teeth}T")
    print(f"Created gear with {teeth} teeth")

# Use print() liberally to track execution
print("Starting gear generation...")

for tooth_num in range(num_teeth):
    print(f"  Generating tooth {tooth_num+1}/{num_teeth}")
    # ... code ...

print("✓ Gear complete!")

import traceback

try:
    # Your code here
    gear = create_involute_gear(module=2.5, num_teeth=24)
    Part.show(gear)

except Exception as e:
    print(f"Error occurred: {e}")
    traceback.print_exc()  # Print full error trace

def create_gear(module, num_teeth):
    # Validate inputs
    if module <= 0:
        raise ValueError("Module must be positive")
    if num_teeth < 4:
        raise ValueError("Need at least 4 teeth")

    # ... rest of code ...