feature request: ability to use __geo_interface__ properties as dxfattribs in to_dxf_entities

[sanzoghenzo]

Hi, first of all many thanks for this wonderful library!

I'm mainly using it to convert GeoPandas dataframes to DXF, and a while ago I wrote a module to do that.
Now that I discovered the geo addon, I'm trying to move my code to it.

My GeoDataFrames store the target layer name in a column, and I can use a groupby to process the features with the same layer:

from ezdxf.addons.geo import dxf_entities
from ezdxf.document import Drawing
from geopandas import GeoDataFrame

def to_dxf(gdf: GeoDataFrame, layers_column: str, drawing: Drawing) -> None:
    mdl = drawing.modelspace()
    for layer, features in gdf.groupby(layers_column):
        for entity in dxf_entities(
            features, dxfattribs={"layer": layer}
        ):
            mdl.add_entity(entity)

Now I would like to use other style parameters from the geodataframe columns, such as color and transparency; I could use the same strategy passing multiple by columns in the groupby method, but I was wondering if this could be a feature to add to dxf_entities/GeoProxy.to_dxf_entities, since the info are available in the "properties" property of the parsed GeoProxy class.

Something like optional layer_property, color_property, transparency_property argument, maybe?
Or better yet a dxfattribs_function to specify a function that returns a dictionary for dxfattribs given the feature properties as argument.

[mozman]

I don't understand your question nor have I ever used geopandas. You can pass additional DXF attributes to the dxf_entities() function by the dxfattribs dictionary, such as color and transparency.

[sanzoghenzo]

Sorry if I was not clear; I'll try to be more exaustive.

Let's forget about GeoPandas, since this is something that applies also to __geo_interface__ in general.

My goal is to set the dxfattribs of an entity based on the properties of the source geospatial feature. The current methods only allow to set a single dxfattribs for all the entities.

Let's say we have the following __geo_interface__

feature_coll = {
    "type": "FeatureCollection",
    "features": [
        {
            "id": "0",
            "type": "Feature",
            "properties": {"layer": "awesome", "color": 5, "transparency": 0.3},
            "geometry": {"type": "Point", "coordinates": (1.0, 2.0)},
            "bbox": (1.0, 2.0, 1.0, 2.0),
        },
        {
            "id": "1",
            "type": "Feature",
            "properties": {"layer": "ugly", "color": 10, "transparency": 0},
            "geometry": {"type": "Point", "coordinates": (2.0, 1.0)},
            "bbox": (2.0, 1.0, 2.0, 1.0),
        },
    ],
    "bbox": (1.0, 1.0, 2.0, 2.0),
}

I would like to use the "layer", "color" and "transparency" values to set the style of the resulting points (maybe points are not the best examples, but I hope you get the idea).

What I have in mind is a dxfattribs_function that accepts a function like the following as argument:

def set_attribs(properties):
    return {"color": properties["color"], "layer": properties["layer"], ...}

or something more elaborate, to be called before this line like

final_dxfattribs = dxfattribs_function(_mapping.get("properties")) if dxfattribbs_function else dxfattribs

and then pass final_dxfattribs to the inner functions.

[mozman]

OK, I understand.

This is the current core loop of GeoProxy.to_dxf_entities() in geo.py:

dxfattribs = dict(dxfattribs or {})   # final DXF attributes, a function-wide global
for _mapping in self.__iter__():
    yield from entity(_mapping.get(TYPE), _mapping.get(COORDINATES))

You want something like this for pre-processing the properties of a mapping:

def to_dxf_entities(self, polygon, dxfattribs, pre_process):
    ...
    base_attribs = dict(dxfattribs or {})
    dxfattrib = base_attribs
    for _mapping in self.__iter__():
        if pre_process:
             dxfattribs = base_attribs.copy()  # the new final DXF attribs 
             dxfattribs.update(pre_process(_mapping.get("properties")))
        yield from entity(_mapping.get(TYPE), _mapping.get(COORDINATES))

This could be done more flexible as post process option:

def to_dxf_entities(self, polygon, dxfattribs, post_process):
    ...
    dxfattribs = dict(dxfattribs or {})
    for _mapping in self.__iter__():
        for e in entity(_mapping.get(TYPE), _mapping.get(COORDINATES))
             # e is the new created DXF entity
             # this allows additional post processing not only DXF attributes, like storing the "id" as XDATA
             if post_process:
                 post_process(e, _mapping)
             yield e

A post process function could look like this:

def post_process(entity, mapping):
    properties = mapping.get("properties")
    if properties:
        entity.dxf.color = properties.get("color", BYLAYER)

Is there a standard for properties like GeoJSON for geometries?

[sanzoghenzo]

I like the post_process approach! It also answers the transparency issue I previously left out (if I understand correctly it is not part of the dxfattribs dictionary).

GeoJSON specification says only that the properties value can be a JSON object or a null values, so there's no constraints on it.

[mozman]

1. Transparency is a basic DXF attribute, but its awkward. 😄
2. I asked for a standard for properties so I can provide a reference implementation of the post_process function to assign properties. Maybe you can provide an an example for common usage of properties. I assume transparency is a float for 0 to 1, colors are hex-strings or RGB-tuples, layers are strings, lineweight/width???, ...

[mbway]

the 'properties' of a geojson feature is entirely application specific. It's a place to put arbitrary data. So I think it makes the most sense to have the default post_process do nothing

[mozman]

I tried to implement this feature and noticed that the current design only handles the "geometry" nodes, this requires much more work and may break existing code. GeoProxy.__iter__() yields only "geometry" nodes.

[sanzoghenzo]

Oh, that's right... I can live with the grouping method explained in the first post for now, and if I ever really need it I'll found the time for a pr!

As @mbway said, the properties attached to features are arbitrary, and depends on the application domain (mine is usually buildings engineering and I use height, foundations level, structure type, and so on).
That said, there's a case that might be useful for this: the QGIS dxf/dwg importer creates a gpkg database with styling info in the attributes table. I'll post an example soon (away from the pc atm)

[mozman]

Added a new implementation which should work now.

[mozman]

Does anyone know how GeometryCollections are used in Features exactly? Maybe showing an example.

My assumption is this: Feature->geometry->GeometryCollection->geometries->[Point, Point, ...]

{
    "type": "Feature",
    "properties": {"layer": "GeoJSON"},
    "geometry": {
        "type": "GeometryCollection",
        "geometries": [
               {
                    "type": "Point", 
                    "coordinates": [0, 0]
                },
                {
                    "type": "Point", 
                    "coordinates": [1, 1]
                }
          ]
     }
}

[mbway]

Unlike DXF, the geojson spec is very good and even includes examples 🙂
GeometryCollection example

I think your example is correct.

GeometryCollection a heterogeneous collection so the elements can be different geometry types. If you want to attach properties to the different geometry then you need a FeatureCollection instead.

Also you might find a tool like this useful if you want to check that some JSON is valid geojson https://geojsonlint.com/