Generate section from solid and vertical alignment view

[schoeller]

Below script takes a solid and a vertical alignment view as input. It then find closest start/stop stations on the horizontal alignment attached to the vertical alignment view. Using these points a section is generated with a block cutting the solid. Lastly the block is added as a scaled blockref to the vertical alignment view.

import traceback
import math
from pyrx import Ge, Db, Ap, Br, Ed, Cv

def create_section(db: Db.Database, pts: list[Ge.Point3d], ids: list[Db.ObjectId], name: str, height: float) -> Db.Section:
    smid = db.getSectionManagerId()
    sm = Db.SectionManager(smid)
    for id in sm.objectIds():
        ent = Db.Section(id, Db.OpenMode.kForWrite)
        if ent.getName() == name:
            ent.erase()

    sec = Db.Section(pts, Ge.Vector3d.kZAxis)
    sec.setState(Db.SectionState.kPlane)
    sec.enableLiveSection(False)
    sec.setHeight(Db.SectionHeight.kHeightAboveSectionLine, height)
    sec.setHeight(Db.SectionHeight.kHeightBelowSectionLine, height)
    sec.setName(name)
    secid = db.addToModelspace(sec)

    ss = Db.SectionSettings(sec.getSettings(), Db.OpenMode.kForWrite)
    ss.setCurrentSectionType(Db.SectionType.k2dSection)
    ss.setSourceObjects(Db.SectionType.k2dSection, ids)
    ss.setVisibility(Db.SectionType.k2dSection, Db.SectionGeometry.kBackgroundGeometry, True)
    ss.setHiddenLine(Db.SectionType.k2dSection, Db.SectionGeometry.kBackgroundGeometry, False)
    opts = Db.SectionGeneration.kSourceSelectedObjects | Db.SectionGeneration.kDestinationFile
    ss.setGenerationOptions(Db.SectionType.k2dSection, Db.SectionGeneration(opts))
    return sec

def create_section_block(db: Db.Database, name: str, entities: list[Db.Entity]) -> Db.ObjectId:
    bt = Db.BlockTable(db.blockTableId(), Db.OpenMode.kForWrite)
    if bt.has(name):
        ent = Db.BlockTableRecord(bt.getAt(name), Db.OpenMode.kForWrite)
        ent.erase()
    btr = Db.BlockTableRecord()
    btr.setName(name)
    btrid = bt.add(btr)
    btr.appendAcDbEntities(entities)
    return btrid

def create_block_ref(db: Db.Database, btrid: Db.ObjectId, coords: Ge.Point3d, scale: Ge.Scale3d) -> Db.ObjectId:
    block_ref = Db.BlockReference(coords, btrid)
    block_ref.setScaleFactors(scale)
    model = Db.BlockTableRecord(db.modelSpaceId(), Db.OpenMode.kForWrite)
    return model.appendAcDbEntity(block_ref)

@Ap.Command()
def doit15():
    try:
        db = Db.curDb()

        # Select solid and vertical alignment view
        es = Ed.Editor.entSel("\nSelect: ", Db.Solid3d.desc())
        if es[0] != Ed.PromptStatus.eOk:
            raise RuntimeError("Yeet! {}: ".format(es[0]))
        source_ids = [es[1]]

        es = Ed.Editor.entSel("\nSelect Vertical Alignment View: ", Cv.CvDbVAlignmentView.desc())
        if es[0] != Ed.PromptStatus.eOk:
            raise RuntimeError("Yeet! {}: ".format(es[0]))
        
        # Prepare info
        vAlignView = Cv.CvDbVAlignmentView(es[1])
        hAlign = Cv.CvDbHAlignment(vAlignView.baseHAlignment())
        stationEq = hAlign.stationEquations()
        fs = stationEq.getStartingStation()
        ls = stationEq.getStation(stationEq.getRawStationFromLength(hAlign.length()))
        min_sta, max_sta = ls, fs
        zmin, zmax = -math.inf, math.inf
        base = vAlignView.baseElevation()
        top = base + (vAlignView.height() / vAlignView.verticalScale())
        scalev = vAlignView.verticalScale()
        scaleh = vAlignView.horizontalScale()

        # Traverse vertices in solid
        for source_id in source_ids:
            solid = Db.Solid3d(source_id)
            vt = Br.VertexTraverser(Br.Brep(solid))

            for vtx in vt.getVertexs():
                pt = vtx.getPoint()
                closest = hAlign.getClosestPointTo(pt)
                found, station, proxi = hAlign.getStationAtPoint(Ge.Point2d(closest.x, closest.y))

                if found:
                    min_sta = min(min_sta, station)
                    max_sta = max(max_sta, station)
                    zmin = min(zmin, pt.z)
                    zmax = max(zmax, pt.z)

            if zmax < base or zmin > top:
                print("\nSection outside of view, not plotting")
                return

        # Create section line
        start_pt = hAlign.getPointAtStation(min_sta)[1]
        end_pt = hAlign.getPointAtStation(max_sta)[1]
        mid_z = (top + base) / 2
        pts = [Ge.Point3d(start_pt.x, start_pt.y, mid_z), Ge.Point3d(end_pt.x, end_pt.y, mid_z)]
        sec_height = mid_z - base
        name = f"{vAlignView.name()} - {station:08.1f}"
        sec = create_section(db, pts, source_ids, name, sec_height)

        # Create and transform section block
        mat = Ge.Matrix3d().setToAlignCoordSys(
            Ge.Point3d(pts[0].x, pts[0].y, pts[0].z),
            sec.plane()[0],
            sec.verticalDirection(),
            sec.viewingDirection(),
            Ge.Point3d.kOrigin,
            Ge.Vector3d.kXAxis,
            Ge.Vector3d.kYAxis,
            Ge.Vector3d.kZAxis
        )

        section_geo = []
        for source_id in source_ids:
            ent = Db.Entity(source_id)
            for items in sec.generateSectionGeometry(ent):
                section_geo.extend(item.getTransformedCopy(mat) for item in items)
        blkid = create_section_block(db, name, section_geo)

        # Determine insert point and create blockref
        pt = vAlignView.toWCSPoint2d(Ge.Point2d(min_sta/scaleh, base + sec_height))
        create_block_ref(db, blkid, Ge.Point3d(pt.x, pt.y, 0), Ge.Scale3d(1*scaleh, 1*scalev, 1.0))

    except Exception as err:
        traceback.print_exception(err)