3d-vase-mode-art

name	3d-vase-mode-art
description	Generates single-wall spiral vase STLs (sine, twisted polygon, Gielis superformula) and Bambu Studio/Cura/PrusaSlicer Spiralize Outer Contour settings for decorative prints, LED lamp shades, and manual/gradient multi-color bands. Use when the user asks for vase mode, spiral vase, parametric vase STLs, or translucent lamp-shade prints. Not for tabletop miniatures (3d-miniature-figurine), photo-to-mesh conversion (3d-image-to-model), or AMS automatic color swaps on a pure spiral path.
version	1.0.1

Vase Mode / Spiral Art for 3D Printing

Overview

Vase mode — also called Spiralize Outer Contour (Cura/Bambu Studio) or Spiral Vase (PrusaSlicer) — is a specialized 3D printing technique that produces hollow, single-walled objects in one continuous, uninterrupted spiral motion. The printer head never retracts or lifts; the Z-axis rises gradually as the nozzle traces the outer contour, producing one continuous strand of filament from bottom to top.

Aspect	Standard Printing	Vase Mode
Layers	Discrete start/stop per layer	Continuous Z-rise spiral
Walls	Multiple perimeters + infill	Single outer wall only
Z-Seam	Visible vertical line	Eliminated entirely
Top layers	Solid top shell	None (open top)
Infill	Configurable percentage	0% (hollow)
Speed	Normal	Often faster (no travel moves)

Requirements and Limitations

• Model must have a single, continuous cross-section at every height
• No overhangs, handles, bridges, or detached internal geometry
• No multiple shells or internal cavities
• Bottom layers are printed normally (3–5 solid layers for a stable base)
• Objects are inherently fragile — single-wall thickness only
• Best suited for decorative rather than functional objects

Ideal Objects

• Vases and planters
• Lamp shades and light diffusers
• Pencil/pen holders
• Sculptural art pieces
• Decorative bowls
• Geometric sculptures
• Candle holders

When to Use

Trigger this skill when the user mentions any of:

• "vase mode", "spiral vase", "spiralize outer contour"
• Generating parametric or mathematical vase STLs
• Bambu Studio / PrusaSlicer / Cura vase mode settings
• LED lamp shade 3D printing
• Multi-color vase printing workarounds
• OpenSCAD or Python vase generation
• Superformula / Gielis surface generation for 3D printing

Prerequisites

Python Environment (for STL generation)

pip install numpy numpy-stl

Slicer

• Bambu Studio (primary reference; 2.0+ recommended for Smooth Spiral)
• PrusaSlicer or Cura also support equivalent "Spiral Vase" mode

Windows Host Notes

• Commands shown are PowerShell-compatible
• Python scripts can be saved anywhere; run from the project directory
• STL output paths should use backslashes or forward slashes — both work in Python on Windows

Procedure

Step 1: Determine the Goal

Identify what the user wants to create:

1. Decorative vase — standard single-wall object
2. Lamp shade — translucent material, even wall thickness, LED integration
3. Planter — thicker walls, more bottom layers
4. Sculptural art — exotic mathematical surfaces

Step 2: Select the Generation Approach

Goal	Recommended Approach
Simple twisted shapes	OpenSCAD with linear_extrude
Complex math surfaces	Python with numpy-stl
Exotic organic shapes	Superformula generator
Polygon cross-sections	Twisted polygon generator

Step 3: Mathematical Surface Generation

A vase is a surface of revolution where the radius varies as a function of both height (z) and angle (θ).

Core Parametric Equations

x(θ, z) = r(θ, z) · cos(θ + twist(z))
y(θ, z) = r(θ, z) · sin(θ + twist(z))
z(θ, z) = z

Where r(θ, z) is the radius function and twist(z) adds rotational offset.

Common Radius Functions

Simple Sine Wave Vase:

r(θ, z) = base_radius + amplitude · sin(n · θ + phase · z)

• n controls the number of lobes around the circumference
• phase · z rotates the pattern as height increases (twist)
• amplitude controls the depth of the wave

Twisted Polygon Vase:

r(θ, z) = base_radius / cos(mod(θ + twist_rate · z, 2π/sides) - π/sides)

• Creates a polygon cross-section that twists with height
• sides = number of polygon sides
• twist_rate = radians of rotation per unit height

Fractal/Noise Vase:

r(θ, z) = base_radius + Σ(aᵢ · sin(nᵢ · θ + φᵢ · z))

• Sum of multiple sine waves at different frequencies creates organic, fractal-like surfaces
• Each term i has its own amplitude aᵢ, frequency nᵢ, and phase φᵢ

Superformula Vase (Gielis Superformula):

r(θ) = ( |cos(m·θ/4)/a|^n2 + |sin(m·θ/4)/b|^n3 )^(-1/n1)

• Generates an enormous variety of natural-looking shapes
• Parameters m, n1, n2, n3, a, b control the form

Step 4: Generate the STL

4a. Sine Wave Vase Generator

Save as generate_sine_vase.py and run:

python generate_sine_vase.py

"""
Parametric Sine Wave Vase Generator
Generates a single-shell STL suitable for vase mode printing.
"""
import numpy as np
from stl import mesh

def generate_sine_vase(
    height: float = 100.0,
    base_radius: float = 30.0,
    amplitude: float = 8.0,
    lobes: int = 5,
    twist_rate: float = 0.03,
    z_profile_func=None,
    n_theta: int = 200,
    n_z: int = 300,
    output_file: str = "sine_vase.stl",
) -> None:
    """
    Generate a sine-wave vase and export as STL.

    Args:
        height: Total vase height in mm.
        base_radius: Average radius in mm.
        amplitude: Sine wave amplitude in mm.
        lobes: Number of sine lobes around circumference.
        twist_rate: Twist in radians per mm of height.
        z_profile_func: Optional callable(z, height) -> scale factor for radius.
        n_theta: Angular resolution (number of points around circumference).
        n_z: Vertical resolution (number of layers).
        output_file: Output STL filename.
    """
    if z_profile_func is None:
        # Default: slight hourglass shape
        def z_profile_func(z: float, h: float) -> float:
            t = z / h
            return 0.7 + 0.6 * (t - 0.3) ** 

    theta = np.linspace(,  * np.pi, n_theta, endpoint=)
    z_vals = np.linspace(, height, n_z)

    
    vertices = np.zeros((n_z, n_theta, ))
     i, z  (z_vals):
        profile_scale = z_profile_func(z, height)
        twist = twist_rate * z
         j, th  (theta):
            r = (base_radius + amplitude * np.sin(lobes * th + twist * lobes)) * profile_scale
            vertices[i, j, ] = r * np.cos(th + twist)
            vertices[i, j, ] = r * np.sin(th + twist)
            vertices[i, j, ] = z

    
    faces = []
     i  (n_z - ):
         j  (n_theta):
            j_next = (j + ) % n_theta
            
            v0 = vertices[i, j]
            v1 = vertices[i, j_next]
            v2 = vertices[i + , j_next]
            v3 = vertices[i + , j]
            faces.append([v0, v1, v2])
            faces.append([v0, v2, v3])

    
    bottom_center = np.array([, , ])
     j  (n_theta):
        j_next = (j + ) % n_theta
        faces.append([bottom_center, vertices[, j_next], vertices[, j]])

    
    face_array = np.array(faces)
    stl_mesh = mesh.Mesh(np.zeros(face_array.shape[], dtype=mesh.Mesh.dtype))
     i, f  (face_array):
        stl_mesh.vectors[i] = f

    stl_mesh.save(output_file)
    ()


 __name__ == :
    
    generate_sine_vase(
        height=,
        base_radius=,
        amplitude=,
        lobes=,
        twist_rate=,
        output_file=,
    )

    
    generate_sine_vase(
        height=,
        base_radius=,
        amplitude=,
        lobes=,
        twist_rate=,
        output_file=,
    )

    
     () -> :
        t = z / h
          +  * np.sin(t * np.pi) +  * np.sin( * t * np.pi)

    generate_sine_vase(
        height=,
        base_radius=,
        amplitude=,
        lobes=,
        twist_rate=,
        z_profile_func=organic_profile,
        output_file=,
    )

4b. Twisted Polygon Vase Generator

Save as generate_twisted_polygon_vase.py and run:

python generate_twisted_polygon_vase.py

"""
Twisted Polygon Vase Generator
Creates a polygon cross-section that twists along the Z axis.
"""
import numpy as np
from stl import mesh

def generate_twisted_polygon_vase(
    height: float = 120.0,
    radius: float = 35.0,
    sides: int = 5,
    twist_degrees: float = 90.0,
    corner_radius: float = 3.0,
    n_theta: int = 200,
    n_z: int = 250,
    output_file: str = "twisted_polygon_vase.stl",
) -> None:
    """
    Generate a twisted polygon vase.

    Args:
        height: Vase height in mm.
        radius: Inscribed circle radius in mm.
        sides: Number of polygon sides.
        twist_degrees: Total twist from bottom to top.
        corner_radius: Smoothing radius for corners.
        n_theta: Angular resolution.
        n_z: Vertical resolution.
        output_file: Output filename.
    """
    twist_total = np.radians(twist_degrees)
    theta = np.linspace(0, 2 * np.pi, n_theta, endpoint=False)
    z_vals = np.linspace(0, height, n_z)

    vertices = np.zeros((n_z, n_theta, 3))
    for i, z in enumerate(z_vals):
        t = z / height
        twist = twist_total * t
        # Slight taper: wider in middle
        scale = 0.8 + 0.4 * np.sin(t * np.pi)
        for j, th in enumerate(theta):
            # Polygon radius with smoothed corners
            angle_in_sector = ((th + twist) % ( * np.pi / sides)) - np.pi / sides
            r = radius / np.cos(angle_in_sector)
            
            r = (r, radius + corner_radius)
            r *= scale
            vertices[i, j, ] = r * np.cos(th)
            vertices[i, j, ] = r * np.sin(th)
            vertices[i, j, ] = z

    
    faces = []
     i  (n_z - ):
         j  (n_theta):
            j_next = (j + ) % n_theta
            v0, v1 = vertices[i, j], vertices[i, j_next]
            v2, v3 = vertices[i + , j_next], vertices[i + , j]
            faces.append([v0, v1, v2])
            faces.append([v0, v2, v3])

    
    center = np.array([, , ])
     j  (n_theta):
        j_next = (j + ) % n_theta
        faces.append([center, vertices[, j_next], vertices[, j]])

    face_array = np.array(faces)
    stl_mesh = mesh.Mesh(np.zeros(face_array.shape[], dtype=mesh.Mesh.dtype))
     i, f  (face_array):
        stl_mesh.vectors[i] = f

    stl_mesh.save(output_file)
    ()


 __name__ == :
    generate_twisted_polygon_vase(sides=, twist_degrees=, output_file=)
    generate_twisted_polygon_vase(sides=, twist_degrees=, output_file=)
    generate_twisted_polygon_vase(sides=, twist_degrees=, output_file=)

4c. Superformula Vase Generator

Save as generate_superformula_vase.py and run:

python generate_superformula_vase.py

"""
Superformula Vase Generator
Uses the Gielis superformula for exotic natural shapes.
"""
import numpy as np
from stl import mesh

def superformula(theta: float, m: float, n1: float, n2: float, n3: float,
                 a: float = 1.0, b: float = 1.0) -> float:
    """Compute the Gielis superformula radius for a given angle."""
    t1 = np.abs(np.cos(m * theta / 4.0) / a)
    t2 = np.abs(np.sin(m * theta / 4.0) / b)
    r = (t1 ** n2 + t2 ** n3) ** (-1.0 / n1)
    return r

def generate_superformula_vase(
    height: float = 120.0,
    scale: float = 30.0,
    m: float = 6.0,
    n1: float = 1.0,
    n2: float = 1.0,
    n3: float = 1.0,
    twist_rate: float = 0.02,
    n_theta: int = 300,
    n_z: int = 300,
    output_file: str = "superformula_vase.stl",
) -> None:
    """Generate a vase using the Gielis superformula cross-section."""
    theta = np.linspace(,  * np.pi, n_theta, endpoint=)
    z_vals = np.linspace(, height, n_z)

    vertices = np.zeros((n_z, n_theta, ))
     i, z  (z_vals):
        t = z / height
        twist = twist_rate * z
        profile =  +  * np.sin(t * np.pi)
         j, th  (theta):
            r = superformula(th + twist, m, n1, n2, n3) * scale * profile
            vertices[i, j, ] = r * np.cos(th)
            vertices[i, j, ] = r * np.sin(th)
            vertices[i, j, ] = z

    faces = []
     i  (n_z - ):
         j  (n_theta):
            j_next = (j + ) % n_theta
            v0, v1 = vertices[i, j], vertices[i, j_next]
            v2, v3 = vertices[i + , j_next], vertices[i + , j]
            faces.append([v0, v1, v2])
            faces.append([v0, v2, v3])

    center = np.array([, , ])
     j  (n_theta):
        j_next = (j + ) % n_theta
        faces.append([center, vertices[, j_next], vertices[, j]])

    face_array = np.array(faces)
    stl_mesh = mesh.Mesh(np.zeros(face_array.shape[], dtype=mesh.Mesh.dtype))
     i, f  (face_array):
        stl_mesh.vectors[i] = f

    stl_mesh.save(output_file)
    ()


 __name__ == :
    
    generate_superformula_vase(m=, n1=, n2=, n3=, output_file=)
    
    generate_superformula_vase(m=, n1=, n2=, n3=, output_file=)
    
    generate_superformula_vase(m=, n1=, n2=, n3=, output_file=)

4d. OpenSCAD Twisted Vase (Alternative)

For simple shapes without Python, use OpenSCAD:

// Twisted Star Vase for Vase Mode
$fn = 200;

height = 120;
base_r = 30;
lobes = 5;
amplitude = 8;
twist = 90; // degrees total twist

module vase_slice(z) {
    t = z / height;
    profile = 0.6 + 0.8 * sin(t * 180);
    twist_angle = twist * t;

    rotate([0, 0, twist_angle])
    hull() {
        for (a = [0:360/lobes:359]) {
            rotate([0, 0, a])
            translate([base_r * profile + amplitude * profile, 0, 0])
            circle(r = 0.5);
        }
    }
}

module vase() {
    step = 0.5;
    for (z = [0:step:height]) {
        translate([0, 0, z])
        linear_extrude(height = step + 0.01)
        vase_slice(z);
    }
}

vase();

Step 5: Profile Functions for Z-Axis Shaping

Use these as the z_profile_func parameter in the sine wave generator:

# Hourglass: narrow in the middle
def hourglass(z: float, h: float) -> float:
    t = z / h
    return 0.6 + 0.8 * (2 * t - 1) ** 2

# Trumpet: flares at the top
def trumpet(z: float, h: float) -> float:
    t = z / h
    return 0.5 + 1.5 * t ** 2

# Bulge: wide belly
def bulge(z: float, h: float) -> float:
    t = z / h
    return 0.6 + 0.8 * np.sin(t * np.pi)

# S-curve: two bulges
def s_curve(z: float, h: float) -> float:
    t = z / h
    return 0.6 + 0.4 * np.sin(2 * t * np.pi)

# Straight cylinder
def cylinder(z: float, h: float) -> float:
    return 1.0


 () -> :
    t = z / h
      + t

Step 6: Configure Bambu Studio Vase Mode Settings

1. Open Bambu Studio and load your model
2. Go to Process Settings → Others tab
3. Under Special Mode, enable Spiral Vase
4. Enable Smooth Spiral (available in Bambu Studio 2.0+) to eliminate Z-seam artifacts

Automatic adjustments when enabled:

• Wall loops: 1
• Top shell layers: 0
• Infill density: 0%
• Only bottom layers remain solid

Recommended settings by application:

Setting	Decorative Vase	Lamp Shade	Planter
Layer Height	0.20 mm	0.12–0.16 mm	0.20 mm
Line Width	0.45–0.60 mm	0.50–0.60 mm	0.60–0.80 mm
Outer Wall Speed	40–50 mm/s	25–30 mm/s	40 mm/s
Bottom Layers	3–4	4–5	5–6
Nozzle Temp	Standard	5°C lower	Standard
Flow Rate	100–105%	100%	105–110%

Tips for better results:

• Wider lines (0.6mm+ on a 0.4mm nozzle) create thicker, more rigid walls
• Slower speeds on the outer wall improve surface quality, especially for translucent materials
• Increase flow by 5–10% to ensure good layer bonding with wider lines
• Use a textured plate for the first layer if using PLA to prevent sticking issues
• Ensure a stable base with enough bottom solid layers (at least 4)

Step 7: LED Lamp Shade Integration

Translucent Materials

Material	Translucency	Notes
Natural/Clear PLA	High	Best light diffusion; moisture-sensitive
Translucent PETG	Medium-High	Better temperature resistance near LEDs
Silk PLA	Medium	Beautiful shimmer effect when backlit
Marble PLA	Low-Medium	Creates interesting shadow patterns
Glow-in-dark PLA	Medium	Charges from LEDs, glows after off

Print Settings for Lamp Shades

• Layer height: 0.12–0.16 mm for smooth, even light diffusion
• Line width: 0.50–0.60 mm for consistent wall thickness
• Speed: 25–30 mm/s for outer wall clarity
• Temperature: 5–10°C lower than normal to reduce bubbling
• Dry filament: Moisture causes bubbles that scatter light unevenly

LED Integration Methods

1. Battery-powered LED puck: Place under the vase; simplest approach
2. LED strip coil: Wind an LED strip inside the vase base cavity
3. Dedicated lamp base: Design a separate base with LED holder socket
4. Smart bulb adapter: Design the vase top to fit a standard E26/E27 socket

Design Considerations

• Keep wall thickness uniform for even light distribution
• Avoid sharp corners that create bright spots
• Taller vases need a wider base for stability with LED hardware inside
• Geometric patterns (sine waves, polygons) create stunning shadow projections

Step 8: Multi-Color Vase Mode Techniques

The Limitation: Standard vase mode is a continuous single-path process. The printer cannot stop to purge filament (required for AMS color switching) without creating a visible seam or scar in the wall. Therefore, automated multi-color is not natively supported in pure spiral vase mode.

Workarounds:

1. Manual Filament Swap (Pause Method)

   • Insert a Pause or Filament Change at a specific layer height in the slicer
   • When the printer pauses, cut and manually swap the filament
   • Creates a visible color transition line at the change point
   • Best for horizontal color bands (bottom half one color, top half another)

2. Gradient / Rainbow Filament

   • Use multi-color or gradient filament (e.g., rainbow PLA, tri-color silk)
   • Achieves smooth color transitions without any pauses
   • The transition pattern depends on the filament's color-change cycle length
   • Best for organic, flowing color effects

3. Filament Splicing

   • Manually splice different colored filament segments together on the same spool
   • Precise timing is difficult but allows planned color blocks
   • Use a filament welder or heat splice technique

4. Dual-Extruder Side-by-Side (Non-AMS)

   • Some printers support a second extruder for vase mode
   • One color per extruder, alternating per layer or section

Examples

Shape Catalog

Shape Name	Parameters	Visual Effect
Sine Wave 5-Lobe	lobes=5, amp=8, twist=0.03	Star-like cross section, gentle twist
Twisted Triangle	sides=3, twist=120°	Dramatic triangular spiral
Twisted Hexagon	sides=6, twist=45°	Subtle geometric elegance
Starfish	superformula m=5, n1=2	Organic sea-creature shape
Flower Petal	superformula m=8, n1=0.5	Botanical petal pattern
Double Helix	Two interleaved sine waves	DNA-like spiral pattern
Fractal Noise	Sum of 5+ sine terms	Organic, irregular surface
Hourglass	Profile: pinch at middle	Classic narrow-waist silhouette
Trumpet	Profile: exponential flare at top	Wide opening, narrow base
Egg	Profile: elliptical	Smooth, organic shell

Pitfalls

Issue	Cause	Solution
Visible Z-seam line	Smooth Spiral not enabled	Enable Smooth Spiral in Bambu Studio
Thin/weak walls	Line width too narrow	Increase line width to 0.5–0.6mm
Gaps between layers	Under-extrusion	Increase flow rate 5–10%
Base pops off plate	Insufficient bottom layers	Use 4–5 bottom solid layers
Model has holes	Non-manifold mesh	Repair in MeshLab or PrusaSlicer
Cloudy translucent print	Wet filament, bubbles	Dry filament before printing
Uneven wall thickness	Inconsistent extrusion	Calibrate extruder, check nozzle
Slicer ignores vase mode	Model has internal geometry	Simplify model to single shell
AMS multi-color fails	Vase mode is single continuous path	Use manual pause swap or gradient filament instead
Sharp corners create bright spots	Uneven wall thickness at corners	Use corner_radius smoothing in polygon generator

HARD RULES:

• Always generate watertight meshes with a solid bottom cap
• Never produce models with internal geometry, multiple shells, or detached cavities — the slicer will reject vase mode
• Test the STL in the slicer preview before recommending it for printing
• Do not recommend AMS automated color switching for pure spiral vase mode — it will create visible seams

Verification

Verify STL Generation

After running any generator script, confirm the output:

# Check file exists and has reasonable size
dir *.stl

# Quick Python check for mesh validity
python -c "from stl import mesh; m = mesh.Mesh.from_file('classic_sine_vase.stl'); print(f'Triangles: {len(m.vectors)}'); print(f'Closed: {m.is_closed()}')"

Expected output:

Triangles: 119800
Closed: True

(Triangle count will vary by parameters; is_closed() must return True.)

Verify Slicer Settings

In Bambu Studio after enabling Spiral Vase:

1. Confirm Wall loops = 1 (auto-set)
2. Confirm Top shell layers = 0 (auto-set)
3. Confirm Infill density = 0% (auto-set)
4. Confirm Smooth Spiral is enabled (Bambu Studio 2.0+)
5. Preview the toolpath — it should show a single continuous spiral with no Z-seam dots

Verify Print Readiness

• Slice the model and check the preview for any travel moves (there should be none in the spiral portion)
• Confirm bottom solid layers are present (3–6 depending on application)
• Confirm no top shell exists
• Check estimated print time is reasonable (vase mode is typically faster than standard)

Related Skills

• 3d-printing-fdm-basics — general FDM print setup and calibration
• bambu-studio-slicer-settings — detailed Bambu Studio configuration
• openscad-parametric-modeling — OpenSCAD for procedural geometry
• 3d-printing-materials-guide — filament selection including translucent materials