Injecting uuids during SVG conversion

[bdaniere]

Hello,
I'm using the DXF to SVG conversion but entities uuid are lost in the process.
One of the problem is sub-geometries. Mathplotlib doesn't support groups () so we can't associate one uuid to many geometries in the SVG.
Instead of generating a new uuid for each entity, I plan to keep the original uuid (if there is one) and append _1, _2, ... to each sub-geometry so the SVG keeps unique ids.

I can open a PR but your advice may be useful.

[mbway]

do you mean like when a lypolyline is broken down into several line segments and curves? in which case I think appending _1, _2 etc is a good idea. I'm not sure what question you're asking, is this approach causing problems?

I think you will have problems with INSERT entities. Especially since you can nest INSERTs inside of INSERTs and the 'virtual entities' inside them have no handle in the dxf. I don't know how best you could identify those. Maybe those entities have handles in the block where they originate but I don't know

[mozman]

• All (real) DXF entities stored in a DXF document have a handle (hex-string), accessible by DXFEntity.dxf.handle.
• All virtual entities, which are temporarily created entities by copying the original entity or entities created by instantiating the entity class without using a factory method, have no handle until they are bound to a DXF document.
• The property DXFEntity.uuid returns an UUID for each DXF entity, even virtual entities. This UUID is created at runtime at the first access of the uuid property, it is created by uuid.uuid4(). This UUID is not stored in the DXF file and also would not work for virtual entities, because they are not stored in the DXF file.
• The content entities in block references (INSERT) are always virtual entities. They are the result of copying the original BLOCK entities and transforming them to their new position, orientation and size according the parameters of the INSERT entity. These copies do not carry a reference to the source entity in the BLOCK definition.

[mozman]

Added a new feature to track the source of copied entities, new properties of DXFEntity:

• source_of_copy - get immediate source of an entity copy
• origin_of_copy - get first non virtual source of an entity copy
• is_copy - returns True if the entity is a copy

This makes it possible to trace the copying process back to the original entity, even for entities from an INSERT in an INSERT in ...

But you cannot get the source block reference (INSERT) from a virtual entity.

[mozman]

Added a feature to trace back the source block references of virtual entities:

New properties of DXFEntity:

• has_source_block_reference - is True if the virtual entity was created by a block reference
• source_block_reference - the immediate source block reference (INSERT), which created the virtual entity, otherwise None

Application of this property are shown in this tests:

ezdxf/tests/test_04_dxf_high_level_structs/test_414_block_reference_content.py

Lines 416 to 471 in a37f51c

	class TestSourceBlockReferenceFromNestedBlockReferences:
	@pytest.fixture(scope="class")
	def doc(self):
	doc_ = ezdxf.new()
	blk0 = doc_.blocks.new("BLK0")
	blk1 = doc_.blocks.new("BLK1")
	blk2 = doc_.blocks.new("BLK2")
	blk2.add_point((2, 2))
	blk1.add_point((1, 1))
	# block reference 2
	blk1.add_blockref("BLK2", (2, 2))
	blk0.add_point((0, 0))
	# block reference 1
	blk0.add_blockref("BLK1", (1, 1))
	# block reference 0
	doc_.modelspace().add_blockref("BLK0", (0, 0))
	return doc_
	def test_virtual_entities_from_block_ref_0(self, doc):
	blkref0 = cast(Insert, doc.modelspace()[0])
	assert isinstance(blkref0, Insert) is True
	entities: List[DXFEntity] = list(blkref0.virtual_entities())
	point0 = cast(Point, entities[0])
	assert point0.dxftype() == "POINT"
	assert point0.source_block_reference is blkref0
	# An INSERT entity is a just a simple DXF entity
	blkref1 = cast(Insert, entities[1])
	assert blkref1.dxftype() == "INSERT"
	assert blkref1.source_block_reference is blkref0
	def test_virtual_entities_from_block_ref_1(self, doc):
	blkref0 = cast(Insert, doc.modelspace()[0])
	entities: List[DXFEntity] = list(blkref0.virtual_entities())
	blkref1 = cast(Insert, entities[1])
	entities = list(blkref1.virtual_entities())
	point1 = cast(Point, entities[0])
	assert point1.dxftype() == "POINT"
	assert point1.source_block_reference is blkref1
	blkref2 = cast(Insert, entities[1])
	assert blkref2.dxftype() == "INSERT"
	assert blkref2.source_block_reference is blkref1
	def test_virtual_entities_from_block_ref_2(self, doc):
	blkref0 = cast(Insert, doc.modelspace()[0])
	entities: List[DXFEntity] = list(blkref0.virtual_entities())
	blkref1 = cast(Insert, entities[1])
	entities = list(blkref1.virtual_entities())
	blkref2 = cast(Insert, entities[1])
	for point in blkref2.virtual_entities():
	assert point.dxftype() == "POINT"
	assert point.source_block_reference is blkref2

ezdxf/tests/test_04_dxf_high_level_structs/test_416b_recursive_decompose.py

Lines 118 to 191 in a37f51c

	class TestSourceBlockReferences:
	@pytest.fixture(scope="class")
	def doc(self):
	doc_ = ezdxf.new()
	blk0 = doc_.blocks.new("BLK0")
	blk1 = doc_.blocks.new("BLK1")
	blk2 = doc_.blocks.new("BLK2")
	blk2.add_point((2, 1))
	blk2.add_point((2, 2))
	blk1.add_point((1, 1))
	blk1.add_point((1, 2))
	# block reference 2
	blk1.add_blockref("BLK2", (2, 2))
	blk0.add_point((0, 1))
	blk0.add_point((0, 2))
	# block reference 1
	blk0.add_blockref("BLK1", (1, 1))
	# block reference 0
	doc_.modelspace().add_blockref("BLK0", (0, 0))
	return doc_
	@pytest.fixture(scope="class")
	def entities(self, doc):
	return list(recursive_decompose(doc.modelspace()))
	def test_count_of_expected_virtual_entities(self, entities: List[Point]):
	"""The virtual INSERT entities are not returned by the
	recursive_decompose() function.
	"""
	assert len(entities) == 6, "expected only 6 POINT entities"
	def test_same_source_block_references_blk0(self, entities):
	"""Entities from the same INSERT entity have the same virtual source
	block reference.
	"""
	insert0 = entities[0].source_block_reference
	insert1 = entities[1].source_block_reference
	assert isinstance(insert0, Insert)
	assert insert0 is insert1
	assert insert0.dxf.name == "BLK0"
	def test_same_source_block_references_blk1(self, entities):
	"""Entities from the same INSERT entity have the same virtual source
	block reference.
	"""
	insert0 = entities[2].source_block_reference
	insert1 = entities[3].source_block_reference
	assert insert0 is insert1
	assert insert0.dxf.name == "BLK1"
	def test_same_source_block_references_blk2(self, entities):
	"""Entities from the same INSERT entity have the same virtual source
	block reference.
	"""
	insert0 = entities[4].source_block_reference
	insert1 = entities[5].source_block_reference
	assert insert0 is insert1
	assert insert0.dxf.name == "BLK2"
	def test_link_structure_of_virtual_block_references(self, entities):
	"""It is possible to trace back the nesting structure of the block
	references by the source_block_reference property of the virtual
	INSERT entities.
	"""
	blkref0 = entities[0].source_block_reference
	blkref1 = entities[2].source_block_reference
	blkref2 = entities[4].source_block_reference
	# blkref2 resides in blkref1
	assert blkref2.source_block_reference is blkref1
	# and blkref1 resides in blkref0
	assert blkref1.source_block_reference is blkref0
	# and blkref0 has no source_block_reference
	assert blkref0.source_block_reference is None

[bdaniere]

For the moment, I have chosen not to retrieve the suffix information (an INSERT containing another INSERT): this information is not useful to me and causes other problems with my methodology.

def recover_parent_uuid(entity):
    """
    Retrieve the uuid of the entity or parent entity present in d.modelspace()
    Recovery of the uuid could be replaced by the handle

    :param entity: (ezdxf.entities.)
    :return: (str) parent's uuid
    """

    if not entity.is_virtual and not entity.is_copy:
        # return entity.dxf.handle
        return str(entity.uuid)

    if entity.is_copy:
        entity = entity.origin_of_copy

    if entity.has_source_block_reference:
        if not entity.source_block_reference.is_virtual:
            entity = entity.source_block_reference
        else:
            while entity.has_source_block_reference:
                entity = entity.source_block_reference

    # return entity.dxf.handle
    return str(entity.uuid)

I added the recover_parent_uuid() method to addons.drawing.properties to store this information in the properties (in resolve_all()):

 p.output_id = recover_parent_uuid(entity) 

I would to use this information in the various methods of addons.drawing.matplotlib). For example, for MatplotlibBackend.draw_text() :

    patch = PathPatch(
        transformed_path,
        facecolor=properties.color,
        linewidth=0,
        zorder=self._get_z(),
    )
    patch.set_gid(properties.output_id)
    self.ax.add_patch(patch)

    # self.ax.add_patch(
    # PathPatch(
    # transformed_path,
    # facecolor=properties.color,
    # linewidth=0,
    # zorder=self._get_z(),
    # )
    # ) 

I then get the produced svg to merge the paths of the SVG objects according to their id.
I don't know if this approach is the most efficient but it currently works for simple DXF. I give you an example:

example.zip

• drawing_result.svg : the result of matplotlib.qsave()
• merge_path.svg : the svg after merge of SVG objects

In addition :

• Not all geometries are taken into account: we still find names such as "patch_4".
• I haven't done any tests on more complex DXFs yet
• the use of suffixes seems to me more complex because we recover the uuids by entities and sub entities ---> I had thought of using hash(str(entity.uuid)) in order to have names of type entity_uuid + "" + hash(str(sub_entity.uuid)) + "" hash(str(sub_entity.uuid)). I think there are more relevant solutions