FREE LISP : Draw curved stairs with numbering

 

LISP for Architects: Automatically Generating Curved Stairs from an Arc

In architectural drafting, stairs are one of the most common yet repetitive elements to draw. When designing curved stairs, the process can become time-consuming because each step must be carefully distributed along a curved path while maintaining consistent spacing and alignment.

Using LISP, architects and CAD technicians can automate this process and significantly reduce drafting time. This article introduces a simple yet powerful concept: automatically generating a curved stair layout from a selected arc.

---

The Problem with Manual Drafting

When creating a curved stair manually in PTCAD, the typical workflow involves:

1. Drawing the center arc of the staircase.

2. Calculating the angle division for each step.

3. Drawing radial lines for each riser.

4. Adding inner and outer boundaries.

5. Labeling the steps.

For a staircase with 15–20 steps, this can easily take several minutes. In large projects where multiple stairs exist, the time spent becomes significant. In addition, manual work increases the risk of errors such as:

• Uneven step spacing

• Incorrect stair width

• Misaligned riser lines

• Inconsistent geometry

---

The LISP Solution

A custom LISP routine can automate the entire process. With a single command, the user simply:

1. Selects an Arc representing the stair direction.

2. Inputs the number of steps.

3. Specifies the inner and outer radius of the stair.

The script then automatically:

• Divides the arc into equal angular segments

• Draws riser lines between the inner and outer radius

• Generates the stair layout instantly

This transforms a multi-step manual process into a few seconds of automated drafting.

---

How the Algorithm Works

The logic behind the LISP routine is straightforward:

1. Read the arc geometry:

   • Center point

   • Start angle

   • End angle

2. Calculate the total arc angle:

$$\text{Arc Angle} = \text{End Angle} - \text{Start Angle}$$

3. Divide the arc angle by the number of steps:

$$\text{Step Angle} = \frac{\text{Arc Angle}}{\text{Number of Steps}}$$

4. Generate radial lines using polar coordinates from the arc center.

Each step is positioned by incrementally adding the step angle and projecting points using the polar function.

---

Example Workflow

An architect designing a curved staircase might follow this process:

1. Draw the stair center arc.

2. Run the command:

ARCSTAIR

3. Select the arc.

4. Enter the number of steps (e.g., 12).

5. Input the inner and outer radii.

Within seconds, the stair layout is generated automatically.

---

Benefits for Architectural Practice

Using LISP for curved stair generation offers several advantages:

1. Speed

Tasks that normally take several minutes can be completed in seconds.

2. Accuracy

Steps are mathematically distributed along the arc, eliminating spacing errors.

3. Consistency

Every staircase in a project follows the same geometric logic.

4. Productivity

Architects and drafters can focus more on design rather than repetitive drafting work.

---

Typical Stair Design Considerations

When applying this automation tool, architects should still follow common stair design guidelines:

Parameter	Typical Range
Riser Height	150–180 mm
Tread Depth	250–300 mm
Stair Width	900–1500 mm

The LISP routine simply assists in drafting the geometry; the designer still controls the parameters.

---

Expanding the Tool

This basic curved stair generator can be extended further to include:

• Automatic step numbering

• Stair UP/DOWN arrows

• Stair width control

• Automatic dimension placement

• Generation of 3D stair geometry

• Automatic stair schedule export

With these enhancements, LISP can evolve from a simple drafting aid into a powerful architectural productivity tool.

---

Conclusion

Curved staircases are visually elegant but can be tedious to draft manually. By leveraging LISP automation, architects can transform a repetitive process into a fast and reliable workflow.

A simple script that generates stairs from an arc demonstrates how small automation tools can dramatically improve efficiency in architectural drafting. For firms that frequently work with complex geometry, investing in custom LISP tools can lead to significant gains in both productivity and drawing quality.

Source code

(defun c:CSTAIR ( / ent ed cen rad ang1 ang2 step ang
                    r1 r2 tread i a p1 p2 mid txtpt)
(prompt "\nSelect ARC for stair centerline: ")
(setq ent (car (entsel)))
(setq ed (entget ent))
(if (= (cdr (assoc 0 ed)) "ARC")
(progn
(setq cen (cdr (assoc 10 ed)))
(setq rad (cdr (assoc 40 ed)))
(setq ang1 (cdr (assoc 50 ed)))
(setq ang2 (cdr (assoc 51 ed)))
(setq step (getint "\nEnter number of steps: "))
(setq r1 (getreal "\nInner radius: "))
(setq r2 (getreal "\nOuter radius: "))
(setq ang (/ (- ang2 ang1) step))
(prompt "\nCreating stairs...")
(setq i 0)
(while (<= i step)
(setq a (+ ang1 (* ang i)))
(setq p1 (polar cen a r1))
(setq p2 (polar cen a r2))
(command "LINE" p1 p2 "")
(setq i (+ i 1))
)
(setq i 0)
(while (< i step)
(setq a (+ ang1 (* ang (+ i 0.5))))
(setq mid (polar cen a (/ (+ r1 r2) 2)))
(setq txtpt mid)
(PRINC (ITOA i))
(setq txh (* r1 0.03))
(command "TEXT" txtpt txh 0 (itoa (+ i 1)))
(setq i (+ i 1))
)
(command "ARC" (polar cen ang1 r1) "C" cen (polar cen ang2 r1))
(command "ARC" (polar cen ang1 r2) "C" cen (polar cen ang2 r2))
(setq mid (polar cen (+ ang1 (/ (- ang2 ang1) 2)) r2))
(command "LEADER" mid (polar mid (/ pi 2) 1.0) "" "UP" "")
(prompt "\nCurved stair created successfully.")
)
(prompt "\nSelected object is not ARC.")
)
(princ)
)

FREE LISP : Draw Stair Number

Auto Numbering Along a Line in PTCAD (Using LISP)

When working with drawings such as layout grids, parking numbers, seat numbers, column numbering, or coordinate markers, we often need to place numbers evenly spaced along a straight line. Doing this manually can be slow and error-prone.

This simple LISP routine helps automate the process.

What This LISP Does

The command allows the user to:

1. Specify the number of texts

2. Define the starting number

3. Set the text height

4. Pick a start point and end point

The program will then:

• Place the first number at the start point

• Place the last number at the end point

• Automatically divide the space evenly

• Insert all numbers in sequence

Example result:

1 ---- 2 ---- 3 ---- 4 ---- 5

All numbers are spaced equally along the selected line.

Why This Is Useful

This tool is especially helpful for tasks such as:

• Column numbering in structural drawings

• Parking lot numbering

• Seat numbering in halls or stadiums

• Grid labeling

• Survey or coordinate markers

• Repetitive annotation tasks

Instead of calculating spacing manually, the LISP automatically divides the distance and places the numbers correctly.

Tips for Best Use

✔ Use Object Snap (OSNAP)
Snap precisely to the intended start and end points.

✔ Use appropriate text height
Choose a height that matches the drawing scale.

✔ Plan the numbering direction
Numbers will increase from the first picked point toward the second point.

✔ Use it with construction lines
You can draw a temporary line as a guide and erase it afterward.

✔ Works in all CAD version support LISP
Because the routine uses standard LISP (no Visual LISP functions).

Productivity Benefit

For example:

Manual work

Place text → copy → move → edit numbers → repeat

Using this LISP

Pick start → pick end → done

                 What might take 2–3 minutes manually can be done in just a few seconds.

Here is VDO Link

https://www.tiktok.com/@ptcaduser/video/7613673564130086160?is_from_webapp=1&sender_device=pc&web_id=7486330426983859719

Below is source code.

Command to run  is NLL

(defun c:NLL (/ p1 p2 n startnum hgt i dx dy px py)
  (setq n (getint "\nNumber of texts: "))
  (setq startnum (getint "\nStarting number: "))
  (setq hgt (getreal "\nText height: "))
  (setq p1 (getpoint "\nPick start point of line: "))
  (setq p2 (getpoint p1 "\nPick end point of line: "))
  (setq dx (/ (- (car p2) (car p1)) (- n 1)))
  (setq dy (/ (- (cadr p2) (cadr p1)) (- n 1)))
  (setq i 0)
  (while (< i n)
    (setq px (+ (car p1) (* i dx)))
    (setq py (+ (cadr p1) (* i dy)))
    (command "TEXT" (list px py) hgt "0" (itoa (+ startnum i)))
    (setq i (+ i 1))
  )
  (princ)
)