BCAD V26 CvLabels

[schoeller]

Thx for PyRx.
Trying to programmatically creating CvLabels in BCAD v26.

Goal is to create this a line label style as below, currently stuck with 1#:

Below code is setting bizarre values for readability_bias and line_weight:

import traceback
import logging
from pyrx import Ap, Db, Ge, Cv

logging.basicConfig(level=logging.ERROR)
logger = logging.getLogger(__name__)

print("added command = createstyles")

# Dictionary to configure multiple text styles
text_style_config = {
    "SI-TXT": {
        "name": "SI-TXT",
        "annotative": False,
        "text_size": 0,
        "font": "Arial",
        "bold": False,
        "italic": False,
        "charset": 0,
        "pitch": 2,
        "family": 32,
        "vertical": False
    },
    "ANOTHER-TXT": {
        "name": "ANOTHER-TXT",
        "annotative": True,
        "text_size": 5,
        "font": "Times New Roman",
        "bold": True,
        "italic": False,
        "charset": 0,
        "pitch": 1,
        "family": 32,
        "vertical": False
    }
}

# Dictionary to configure multiple line label styles
line_label_style_config = {
    "SLN_1": {
        "name": "Stützpunkthöhe - Länge - Neigung",
        "created_by": "SSC",
        "description": "Dieser Beschriftungsstil gibt die Stützpunkthöhe, Länge und Neigung eines Segments an.",
        "text_style_name": "SI-TXT",
        "visibility": True,
        "layer": "0",
        "orientation_reference": Cv.OrientationRef.eOrientationReferenceObject,
        "forced_insertion": Cv.ForcedInsertion.eForcedInsertionTop,
        "plan_readable": True,
        "readability_bias": 110.00000000000001, # !!!
        "flip_anchors_with_text": True,
        "components": [
            {
                "type": "Arrow",
                "name": "Neigungspfeil",
                "anchor": 0,
                "anchor_point": Cv.LabelAnchor.eLabelAnchorFeatureLocation,
                "arrow_head_style": "Closed filled",
                "arrow_head_size": 3,
                "rotation": 0,
                "fixed_length": True,
                "length": 9,
                "offset": (0, 0),
                "color": 256,
                "line_type": Db.kByLayer,
                "line_weight": Db.kByLayer # !!!
            },
            # {
            #     "type": "Text",
            #     "name": "Component2",
            #     "properties": {
            #         "content": "Sample Text",
            #         "height": 10
            #     }
            # }
        ]
    },
}

def clean_styles(table_or_manager, default_name: str):
    """Remove all styles except the default."""
    for name, obj_id in table_or_manager.toDict().items():
        if name != default_name:
            try:
                Db.Core.entDel(obj_id)
                print(f"Deleted style: {name}")
            except Exception as e:
                logger.error(f"Failed to delete style '{name}': {e}")

def validate_text_style_config(config: dict):
    """Validate the text style configuration."""
    required_keys = ["name", "annotative", "text_size", "font", "bold", "italic", "charset", "pitch", "family", "vertical"]
    if not all(key in config for key in required_keys):
        raise ValueError(f"Missing required keys in text style config: {config}")

def apply_text_style(tst: Db.TextStyleTable, config: dict):
    """Apply a text style configuration to the text style table."""
    try:
        validate_text_style_config(config)
        ts = Db.TextStyleTableRecord()
        ts.setName(config["name"])
        ts.setAnnotative(Db.AnnotativeStates.kFalse if not config["annotative"] else Db.AnnotativeStates.kTrue)
        ts.setTextSize(config["text_size"])
        ts.setFont(config["font"], config["bold"], config["italic"], config["charset"], config["pitch"], config["family"], config["vertical"])
        tst.add(ts)
        print(f"Applied text style: {config['name']}")
    except Exception as e:
        logger.error(f"Failed to apply text style '{config['name']}': {e}")
        raise

def validate_line_label_style_config(config: dict):
    """Validate the line label style configuration."""
    required_keys = ["name", "created_by", "description", "text_style_name", "visibility", "layer", "orientation_reference", "forced_insertion", "plan_readable", "readability_bias", "flip_anchors_with_text", "components"]
    if not all(key in config for key in required_keys):
        raise ValueError(f"Missing required keys in line label style config: {config}")

def apply_line_label_style(manager: Cv.CvDbLineLabelStyleManager, config: dict, text_style_table: Db.TextStyleTable, block_table: Db.BlockTable, layer_table: Db.LayerTable):
    """Apply a line label style configuration using the text style table."""
    try:
        validate_line_label_style_config(config)
        new_id = manager.createLabelStyle(config["name"])
        style = Cv.CvDbLabelStyle(new_id, Db.OpenMode.kForWrite)
        style.setName(config["name"])
        style.setCreatedBy(config["created_by"])
        style.setDescription(config["description"])

        if not text_style_table.has(config["text_style_name"]):
            raise ValueError(f"Text style '{config['text_style_name']}' not found in table.")
        text_style_id = text_style_table.getAt(config["text_style_name"])
        style.setTextStyle(text_style_id)

        style.setVisibility(config["visibility"])
        if layer_table.has(config["layer"]):
            ltrid = layer_table.getAt(config["layer"])
            style.setLayer(ltrid)
        style.setOrientationReference(config["orientation_reference"])
        style.setForcedInsertion(config["forced_insertion"])
        style.setPlanReadable(config["plan_readable"])
        style.setReadabilityBias(float(config["readability_bias"]))
        style.setFlipAnchorsWithText(config["flip_anchors_with_text"])

        # Add components to the style
        component_handlers = {
            "Text": lambda: Cv.CvDbLabelStyleText(),
            "Block": lambda: Cv.CvDbLabelStyleText(),
            "Line": lambda: Cv.CvDbLabelStyleLine(),
            "Arrow": lambda: Cv.CvDbLabelStyleArrow()
        }

        for component_config in config.get("components", []):
            if component_config["type"] not in component_handlers:
                raise ValueError(f"Unknown component type: {component_config['type']}")
            component = component_handlers[component_config["type"]]()
            component.setName(component_config["name"])

            if component_config["type"] == "Arrow":
                component.setAnchorIndex(component_config["anchor"])
                component.setAnchorPoint(component_config["anchor_point"])
                if block_table.has(component_config["arrow_head_style"]):
                    btrid = block_table.getAt(component_config["arrow_head_style"])
                    component.setArrowHeadStyle(btrid)
                component.setArrowHeadSize(component_config["arrow_head_size"])
                component.setAngle(float(component_config["rotation"]))
                component.setFixedLength(component_config["fixed_length"])
                component.setLength(component_config["length"])
                component.setOffset(Ge.Vector2d(component_config["offset"]))
                clr = Db.Color()
                clr.setColorIndex(component_config["color"])
                component.setColor(clr)
                component.setLineweight(Db.LineWeight(component_config["line_weight"]))

            style.addComponent(component)
        print(f"Applied line label style: {config['name']}")
    except Exception as e:
        logger.error(f"Failed to apply line label style '{config['name']}': {e}")
        raise

@Ap.Command()
def createstyles():
    try:
        db = Db.curDb()
        style_id = Cv.CvDbLineLabelStyleManager.getManagerId(db)
        manager = Cv.CvDbLineLabelStyleManager(style_id)
        tst = Db.TextStyleTable(db.textStyleTableId(), Db.OpenMode.kForWrite)
        bt = Db.BlockTable(db.blockTableId())
        lt = Db.LayerTable(db.layerTableId())

        print("Cleaning manager and table")
        clean_styles(manager, 'Default')
        clean_styles(tst, 'Standard')

        print("Applying text styles")
        for style_config in text_style_config.values():
            apply_text_style(tst, style_config)

        print("Applying line label styles")
        for style_config in line_label_style_config.values():
            apply_line_label_style(manager, style_config, tst, bt, lt)

        print("All styles applied successfully.")
    except Exception as e:
        logger.error(f"Command failed: {e}")
        traceback.print_exc()

Hints are welcome

[CEXT-Dan]

Hi,
style.setReadabilityBias appears to want an argument in radians, so 110.00000000000001 is 1.919862

and line_weight should be by Db.LineWeight.kLnWtByLayer

[schoeller]

        db = Db.curDb()
        lit = Db.LinetypeTable(db.linetypeTableId())
        print(lit.toDict())
        if lit.has("Continuous"):
            print("found")

Gosh, sorry too much holidays in France

[schoeller]

Teadious this import for an occasional scripter like me. I have considered manually configuring in a dwg and then importing via _XREF + _NCOPY. Seems to work as well...

[CEXT-Dan]

If you trying to copy styles from a source drawing, into your current drawing, you can try wblockCloneObjects, see PySamples\PyDb\testWblockCloneObjects.py

[schoeller]

Cheers for the hint. I have this bizarre idea in mind whereby I see an advatage to have repo-controllable clear text definition of style formats. I might have to ditch on that.

[CEXT-Dan]

Food for thought

I made a block library once using SQL. The idea was to have sub block components stored on an SQL server, then build a complete block made of individual components via a larger SQL expression. The DWG components can be stored as a BLOB. I made a prototype with lisp here . The interface basically downloaded the .DWG files to a temp or cache folder, then used wblock

You could do something similar, store individual styles as .DWG BLOBS, along with a .PNG BLOB that shows an example of the style, maybe some extra parameters. Create an interface where users can drag and drop styles into the current drawing.