refactor: excel parse
This commit is contained in:
Blizzard
@@ -0,0 +1,862 @@
|
||||
# Copyright (c) 2019-2022, Manfred Moitzi
|
||||
# License: MIT License
|
||||
from __future__ import annotations
|
||||
from typing import (
|
||||
TYPE_CHECKING,
|
||||
Any,
|
||||
Union,
|
||||
cast,
|
||||
Optional,
|
||||
)
|
||||
import logging
|
||||
|
||||
from ezdxf.math import Vec2, UVec
|
||||
from ezdxf.entitydb import EntitySpace
|
||||
from ezdxf.lldxf import const
|
||||
from ezdxf.lldxf.validator import make_table_key
|
||||
from .base import BaseLayout
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from ezdxf.document import Drawing
|
||||
from ezdxf.layouts import BlockLayout
|
||||
from ezdxf.entities import GeoData, Viewport, DXFLayout, DXFGraphic, BlockRecord
|
||||
|
||||
logger = logging.getLogger("ezdxf")
|
||||
|
||||
|
||||
def get_block_entity_space(doc: Drawing, block_record_handle: str) -> EntitySpace:
|
||||
block_record = doc.entitydb[block_record_handle]
|
||||
return block_record.entity_space # type: ignore
|
||||
|
||||
|
||||
class Layout(BaseLayout):
|
||||
"""
|
||||
Layout representation - base class for :class:`Modelspace` and
|
||||
:class:`Paperspace`
|
||||
|
||||
Every layout consist of a LAYOUT entity in the OBJECTS section, an
|
||||
associated BLOCK in the BLOCKS section and a BLOCK_RECORD_TABLE entry.
|
||||
|
||||
layout_key: handle of the BLOCK_RECORD, every layout entity has this
|
||||
handle as owner attribute (entity.dxf.owner)
|
||||
|
||||
There are 3 different layout types:
|
||||
|
||||
1. :class:`Modelspace`
|
||||
2. active :class:`Paperspace` layout
|
||||
3. inactive :class:`Paperspace` layout
|
||||
|
||||
Internal Structure
|
||||
|
||||
For every layout exist a :class:`BlockLayout` object in
|
||||
:class:`BlocksSection` and a :class:`Layout` object
|
||||
(as :class:`Modelspace` or :class:`Paperspace`) in :class:`Layouts`.
|
||||
|
||||
The entity space of the :class:`BlockLayout` object and the entity space
|
||||
of the :class:`Layout` object are the same object.
|
||||
|
||||
"""
|
||||
|
||||
# plot_layout_flags of LAYOUT entity
|
||||
PLOT_VIEWPORT_BORDERS = 1
|
||||
SHOW_PLOT_STYLES = 2
|
||||
PLOT_CENTERED = 4
|
||||
PLOT_HIDDEN = 8
|
||||
USE_STANDARD_SCALE = 16
|
||||
PLOT_PLOTSTYLES = 32
|
||||
SCALE_LINEWEIGHTS = 64
|
||||
PRINT_LINEWEIGHTS = 128
|
||||
DRAW_VIEWPORTS_FIRST = 512
|
||||
MODEL_TYPE = 1024
|
||||
UPDATE_PAPER = 2048
|
||||
ZOOM_TO_PAPER_ON_UPDATE = 4096
|
||||
INITIALIZING = 8192
|
||||
PREV_PLOT_INIT = 16384
|
||||
|
||||
def __init__(self, layout: DXFLayout, doc: Drawing):
|
||||
self.dxf_layout = layout
|
||||
handle = layout.dxf.get("block_record_handle", "0")
|
||||
try:
|
||||
block_record = doc.entitydb[handle]
|
||||
except KeyError:
|
||||
block_record = _find_layout_block_record(layout) # type: ignore
|
||||
if block_record is None:
|
||||
raise const.DXFStructureError(
|
||||
f"required BLOCK_RECORD #{handle} for layout '{layout.dxf.name}' "
|
||||
f"does not exist"
|
||||
)
|
||||
if block_record.dxftype() != "BLOCK_RECORD":
|
||||
raise const.DXFStructureError(
|
||||
f"expected BLOCK_RECORD(#{handle}) for layout '{layout.dxf.name}' "
|
||||
f"has invalid entity type: {block_record.dxftype()}"
|
||||
)
|
||||
# link is maybe broken
|
||||
block_record.dxf.layout = layout.dxf.handle
|
||||
super().__init__(block_record) # type: ignore
|
||||
|
||||
@classmethod
|
||||
def new(cls, name: str, block_name: str, doc: Drawing, dxfattribs=None) -> Layout:
|
||||
"""Returns the required structures for a new layout:
|
||||
|
||||
- a :class:`BlockLayout` with BLOCK_RECORD, BLOCK and ENDBLK entities
|
||||
- LAYOUT entity in the objects section
|
||||
|
||||
Args:
|
||||
name: layout name as shown in tabs of CAD applications e.g. 'Layout2'
|
||||
block_name: layout block name e.g. '*Paper_Space2'
|
||||
doc: drawing document
|
||||
dxfattribs: additional DXF attributes for LAYOUT entity
|
||||
|
||||
(internal API)
|
||||
|
||||
"""
|
||||
block_layout: BlockLayout = doc.blocks.new(block_name)
|
||||
dxfattribs = dxfattribs or {}
|
||||
dxfattribs.update(
|
||||
{
|
||||
"name": name,
|
||||
"block_record_handle": block_layout.block_record_handle,
|
||||
}
|
||||
)
|
||||
dxf_layout = doc.objects.new_entity("LAYOUT", dxfattribs=dxfattribs)
|
||||
return cls(dxf_layout, doc) # type: ignore
|
||||
|
||||
@classmethod
|
||||
def load(cls, layout: DXFLayout, doc: Drawing):
|
||||
"""Loading interface. (internal API)"""
|
||||
_layout = cls(layout, doc)
|
||||
_layout._repair_owner_tags()
|
||||
return _layout
|
||||
|
||||
@property
|
||||
def name(self) -> str:
|
||||
"""Layout name as shown in tabs of :term:`CAD` applications."""
|
||||
return self.dxf_layout.dxf.name
|
||||
|
||||
@property # dynamic DXF attribute dispatching, e.g. DXFLayout.dxf.layout_flags
|
||||
def dxf(self) -> Any:
|
||||
"""Returns the DXF name space attribute of the associated
|
||||
:class:`~ezdxf.entities.DXFLayout` object.
|
||||
|
||||
This enables direct access to the underlying LAYOUT entity,
|
||||
e.g. ``Layout.dxf.layout_flags``
|
||||
|
||||
"""
|
||||
return self.dxf_layout.dxf
|
||||
|
||||
@property
|
||||
def block_record_name(self) -> str:
|
||||
"""Returns the name of the associated BLOCK_RECORD as string."""
|
||||
return self.block_record.dxf.name
|
||||
|
||||
def _repair_owner_tags(self) -> None:
|
||||
"""Set `owner` and `paperspace` attributes of entities hosted by this
|
||||
layout to correct values.
|
||||
"""
|
||||
layout_key = self.layout_key
|
||||
paperspace = 0 if self.is_modelspace else 1
|
||||
for entity in self:
|
||||
if entity.dxf.owner != layout_key:
|
||||
entity.dxf.owner = layout_key
|
||||
if entity.dxf.paperspace != paperspace:
|
||||
entity.dxf.paperspace = paperspace
|
||||
|
||||
def __contains__(self, entity: Union[DXFGraphic, str]) -> bool:
|
||||
"""Returns ``True`` if `entity` is stored in this layout.
|
||||
|
||||
Args:
|
||||
entity: :class:`DXFGraphic` object or handle as hex string
|
||||
|
||||
"""
|
||||
if isinstance(entity, str): # entity is a handle string
|
||||
entity = self.entitydb[entity] # type: ignore
|
||||
return entity.dxf.owner == self.layout_key # type: ignore
|
||||
|
||||
def destroy(self) -> None:
|
||||
"""Delete all entities and the layout itself from entity database and
|
||||
all linked structures.
|
||||
|
||||
(internal API)
|
||||
"""
|
||||
|
||||
self.doc.objects.delete_entity(self.dxf_layout)
|
||||
# super() deletes block_record and associated entity space
|
||||
super().destroy()
|
||||
|
||||
@property
|
||||
def plot_layout_flags(self) -> int:
|
||||
return self.dxf_layout.dxf.plot_layout_flags
|
||||
|
||||
def reset_extents(
|
||||
self, extmin=(+1e20, +1e20, +1e20), extmax=(-1e20, -1e20, -1e20)
|
||||
) -> None:
|
||||
"""Reset `extents`_ to given values or the AutoCAD default values.
|
||||
|
||||
"Drawing extents are the bounds of the area occupied by objects."
|
||||
(Quote Autodesk Knowledge Network)
|
||||
|
||||
Args:
|
||||
extmin: minimum extents or (+1e20, +1e20, +1e20) as default value
|
||||
extmax: maximum extents or (-1e20, -1e20, -1e20) as default value
|
||||
|
||||
"""
|
||||
dxf = self.dxf_layout.dxf
|
||||
dxf.extmin = extmin
|
||||
dxf.extmax = extmax
|
||||
|
||||
def reset_limits(self, limmin=None, limmax=None) -> None:
|
||||
"""Reset `limits`_ to given values or the AutoCAD default values.
|
||||
|
||||
"Sets an invisible rectangular boundary in the drawing area that can
|
||||
limit the grid display and limit clicking or entering point locations."
|
||||
(Quote Autodesk Knowledge Network)
|
||||
|
||||
The :class:`Paperspace` class has an additional method
|
||||
:meth:`~Paperspace.reset_paper_limits` to deduce the default limits from
|
||||
the paper size settings.
|
||||
|
||||
Args:
|
||||
limmin: minimum limits or (0, 0) as default
|
||||
limmax: maximum limits or (paper width, paper height) as default value
|
||||
|
||||
"""
|
||||
dxf = self.dxf_layout.dxf
|
||||
if limmin is None:
|
||||
limmin = (0, 0)
|
||||
if limmax is None:
|
||||
limmax = (dxf.paper_width, dxf.paper_height)
|
||||
|
||||
dxf.limmin = limmin
|
||||
dxf.limmax = limmax
|
||||
|
||||
def set_plot_type(self, value: int = 5) -> None:
|
||||
"""
|
||||
=== ============================================================
|
||||
0 last screen display
|
||||
1 drawing extents
|
||||
2 drawing limits
|
||||
3 view specific (defined by :attr:`Layout.dxf.plot_view_name`)
|
||||
4 window specific (defined by :meth:`Layout.set_plot_window_limits`)
|
||||
5 layout information (default)
|
||||
=== ============================================================
|
||||
|
||||
Args:
|
||||
value: plot type
|
||||
|
||||
Raises:
|
||||
DXFValueError: for `value` out of range
|
||||
|
||||
"""
|
||||
if 0 <= int(value) <= 5:
|
||||
self.dxf.plot_type = value
|
||||
else:
|
||||
raise const.DXFValueError("Plot type value out of range (0-5).")
|
||||
|
||||
def set_plot_style(self, name: str = "ezdxf.ctb", show: bool = False) -> None:
|
||||
"""Set plot style file of type `.ctb`.
|
||||
|
||||
Args:
|
||||
name: plot style filename
|
||||
show: show plot style effect in preview? (AutoCAD specific attribute)
|
||||
|
||||
"""
|
||||
self.dxf_layout.dxf.current_style_sheet = name
|
||||
self.use_plot_styles(True)
|
||||
self.show_plot_styles(show)
|
||||
|
||||
def get_plot_style_filename(self) -> str:
|
||||
return self.dxf_layout.dxf.current_style_sheet
|
||||
|
||||
def set_plot_window(
|
||||
self,
|
||||
lower_left: tuple[float, float] = (0, 0),
|
||||
upper_right: tuple[float, float] = (0, 0),
|
||||
) -> None:
|
||||
"""Set plot window size in (scaled) paper space units.
|
||||
|
||||
Args:
|
||||
lower_left: lower left corner as 2D point
|
||||
upper_right: upper right corner as 2D point
|
||||
|
||||
"""
|
||||
x1, y1 = lower_left
|
||||
x2, y2 = upper_right
|
||||
dxf = self.dxf_layout.dxf
|
||||
dxf.plot_window_x1 = x1
|
||||
dxf.plot_window_y1 = y1
|
||||
dxf.plot_window_x2 = x2
|
||||
dxf.plot_window_y2 = y2
|
||||
self.set_plot_type(4)
|
||||
|
||||
def get_plot_unit_scale_factor(self) -> float:
|
||||
denom = self.dxf.scale_denominator
|
||||
numerator = self.dxf.scale_numerator
|
||||
scale = 1.0
|
||||
if denom:
|
||||
scale = numerator / denom
|
||||
if self.dxf.plot_paper_units == 1:
|
||||
return scale # mm
|
||||
else:
|
||||
return scale * 25.4 # inch
|
||||
|
||||
# plot layout flags setter
|
||||
def plot_viewport_borders(self, state: bool = True) -> None:
|
||||
self.set_plot_flags(self.PLOT_VIEWPORT_BORDERS, state)
|
||||
|
||||
def show_plot_styles(self, state: bool = True) -> None:
|
||||
self.set_plot_flags(self.SHOW_PLOT_STYLES, state)
|
||||
|
||||
def plot_centered(self, state: bool = True) -> None:
|
||||
self.set_plot_flags(self.PLOT_CENTERED, state)
|
||||
|
||||
def plot_hidden(self, state: bool = True) -> None:
|
||||
self.set_plot_flags(self.PLOT_HIDDEN, state)
|
||||
|
||||
def use_standard_scale(self, state: bool = True) -> None:
|
||||
self.set_plot_flags(self.USE_STANDARD_SCALE, state)
|
||||
|
||||
def use_plot_styles(self, state: bool = True) -> None:
|
||||
self.set_plot_flags(self.PLOT_PLOTSTYLES, state)
|
||||
|
||||
def scale_lineweights(self, state: bool = True) -> None:
|
||||
self.set_plot_flags(self.SCALE_LINEWEIGHTS, state)
|
||||
|
||||
def print_lineweights(self, state: bool = True) -> None:
|
||||
self.set_plot_flags(self.PRINT_LINEWEIGHTS, state)
|
||||
|
||||
def draw_viewports_first(self, state: bool = True) -> None:
|
||||
self.set_plot_flags(self.DRAW_VIEWPORTS_FIRST, state)
|
||||
|
||||
def model_type(self, state: bool = True) -> None:
|
||||
self.set_plot_flags(self.MODEL_TYPE, state)
|
||||
|
||||
def update_paper(self, state: bool = True) -> None:
|
||||
self.set_plot_flags(self.UPDATE_PAPER, state)
|
||||
|
||||
def zoom_to_paper_on_update(self, state: bool = True) -> None:
|
||||
self.set_plot_flags(self.ZOOM_TO_PAPER_ON_UPDATE, state)
|
||||
|
||||
def plot_flags_initializing(self, state: bool = True) -> None:
|
||||
self.set_plot_flags(self.INITIALIZING, state)
|
||||
|
||||
def prev_plot_init(self, state: bool = True) -> None:
|
||||
self.set_plot_flags(self.PREV_PLOT_INIT, state)
|
||||
|
||||
def set_plot_flags(self, flag, state: bool = True) -> None:
|
||||
self.dxf_layout.set_flag_state(flag, state=state, name="plot_layout_flags")
|
||||
|
||||
|
||||
class Modelspace(Layout):
|
||||
""":class:`Modelspace` - not deletable, all entities of this layout are
|
||||
stored in the ENTITIES section of the DXF file, the associated
|
||||
"*Model_Space" block is empty, block name is fixed as "*Model_Space",
|
||||
the name is fixed as "Model".
|
||||
|
||||
"""
|
||||
|
||||
@property
|
||||
def name(self) -> str:
|
||||
"""Name of modelspace is fixed as "Model"."""
|
||||
return "Model"
|
||||
|
||||
def new_geodata(self, dxfattribs=None) -> GeoData:
|
||||
"""Creates a new :class:`GeoData` entity and replaces existing ones.
|
||||
The GEODATA entity resides in the OBJECTS section and not in the
|
||||
modelspace, it is linked to the modelspace by an
|
||||
:class:`~ezdxf.entities.ExtensionDict` located in BLOCK_RECORD of the
|
||||
modelspace.
|
||||
|
||||
The GEODATA entity requires DXF R2010. The DXF reference does not
|
||||
document if other layouts than the modelspace supports geo referencing,
|
||||
so I assume getting/setting geo data may only make sense for the
|
||||
modelspace.
|
||||
|
||||
Args:
|
||||
dxfattribs: DXF attributes for :class:`~ezdxf.entities.GeoData` entity
|
||||
|
||||
"""
|
||||
if self.doc.dxfversion < const.DXF2010:
|
||||
raise const.DXFValueError("GEODATA entity requires DXF R2010 or later.")
|
||||
|
||||
if dxfattribs is None:
|
||||
dxfattribs = {}
|
||||
xdict = self.get_extension_dict()
|
||||
geodata = self.doc.objects.add_geodata(
|
||||
owner=xdict.dictionary.dxf.handle,
|
||||
dxfattribs=dxfattribs,
|
||||
)
|
||||
xdict["ACAD_GEOGRAPHICDATA"] = geodata
|
||||
return geodata
|
||||
|
||||
def get_geodata(self) -> Optional[GeoData]:
|
||||
"""Returns the :class:`~ezdxf.entities.GeoData` entity associated to
|
||||
the modelspace or ``None``.
|
||||
"""
|
||||
try:
|
||||
xdict = self.block_record.get_extension_dict()
|
||||
except AttributeError:
|
||||
return None
|
||||
try:
|
||||
return xdict["ACAD_GEOGRAPHICDATA"]
|
||||
except const.DXFKeyError:
|
||||
return None
|
||||
|
||||
|
||||
class Paperspace(Layout):
|
||||
"""There are two kind of paperspace layouts:
|
||||
|
||||
1. Active Layout - all entities of this layout are stored in the ENTITIES
|
||||
section, the associated "*Paper_Space" block is empty, block name
|
||||
"*Paper_Space" is mandatory and also marks the active layout, the layout
|
||||
name can be an arbitrary string.
|
||||
|
||||
2. Inactive Layout - all entities of this layouts are stored in the
|
||||
associated BLOCK called "*Paper_SpaceN", where "N" is an arbitrary
|
||||
number, I don't know if the block name schema "*Paper_SpaceN" is
|
||||
mandatory, the layout name can be an arbitrary string.
|
||||
|
||||
There is no different handling for active layouts and inactive layouts in
|
||||
`ezdxf`, this differentiation is just for AutoCAD important and it is not
|
||||
documented in the DXF reference.
|
||||
|
||||
"""
|
||||
|
||||
def rename(self, name: str) -> None:
|
||||
"""Rename layout to `name`, changes the name displayed in tabs by
|
||||
CAD applications, not the internal BLOCK name. (internal API)
|
||||
|
||||
Use method :meth:`~ezdxf.layouts.Layouts.rename` of the
|
||||
:meth:`~ezdxf.layouts.Layouts` class to rename paper space
|
||||
layouts.
|
||||
|
||||
"""
|
||||
self.dxf_layout.dxf.name = name
|
||||
|
||||
def viewports(self) -> list[Viewport]:
|
||||
"""Get all VIEWPORT entities defined in this paperspace layout."""
|
||||
return [e for e in self if e.is_alive and e.dxftype() == "VIEWPORT"] # type: ignore
|
||||
|
||||
def main_viewport(self) -> Optional[Viewport]:
|
||||
"""Returns the main viewport of this paper space layout, or ``None``
|
||||
if no main viewport exist.
|
||||
|
||||
"""
|
||||
# Theory: the first VP found is the main VP of the layout, the attributes status
|
||||
# and id are ignored by BricsCAD and AutoCAD!?
|
||||
for viewport in self.viewports():
|
||||
dxf = viewport.dxf
|
||||
if dxf.hasattr("status") and dxf.status == 1:
|
||||
return viewport
|
||||
if dxf.id == 1:
|
||||
return viewport
|
||||
return None
|
||||
|
||||
def add_viewport(
|
||||
self,
|
||||
center: UVec,
|
||||
size: tuple[float, float],
|
||||
view_center_point: UVec,
|
||||
view_height: float,
|
||||
status: int = 2,
|
||||
dxfattribs=None,
|
||||
) -> Viewport:
|
||||
"""Add a new :class:`~ezdxf.entities.Viewport` entity.
|
||||
|
||||
Viewport :attr:`status`:
|
||||
|
||||
- -1 is on, but is fully off-screen, or is one of the viewports that is not
|
||||
active because the $MAXACTVP count is currently being exceeded.
|
||||
- 0 is off
|
||||
- any value>0 is on and active. The value indicates the order of
|
||||
stacking for the viewports, where 1 is the "active viewport", 2 is the
|
||||
next, ...
|
||||
|
||||
"""
|
||||
dxfattribs = dxfattribs or {}
|
||||
width, height = size
|
||||
attribs = {
|
||||
"center": center, # center in paperspace
|
||||
"width": width, # width in paperspace
|
||||
"height": height, # height in paperspace
|
||||
"status": status,
|
||||
"layer": "VIEWPORTS",
|
||||
# use separated layer to turn off for plotting
|
||||
"view_center_point": view_center_point, # in modelspace
|
||||
"view_height": view_height, # in modelspace
|
||||
}
|
||||
attribs.update(dxfattribs)
|
||||
viewport = cast("Viewport", self.new_entity("VIEWPORT", attribs))
|
||||
viewport.dxf.id = self.get_next_viewport_id()
|
||||
return viewport
|
||||
|
||||
def get_next_viewport_id(self):
|
||||
viewports = self.viewports()
|
||||
if viewports:
|
||||
return max(vp.dxf.id for vp in viewports) + 1
|
||||
return 2
|
||||
|
||||
def reset_viewports(self) -> None:
|
||||
"""Delete all existing viewports, and create a new main viewport."""
|
||||
# remove existing viewports
|
||||
for viewport in self.viewports():
|
||||
self.delete_entity(viewport)
|
||||
self.add_new_main_viewport()
|
||||
|
||||
def reset_main_viewport(self, center: UVec = None, size: UVec = None) -> Viewport:
|
||||
"""Reset the main viewport of this paper space layout to the given
|
||||
values, or reset them to the default values, deduced from the paper
|
||||
settings. Creates a new main viewport if none exist.
|
||||
|
||||
Ezdxf does not create a main viewport by default, because CAD
|
||||
applications don't require one.
|
||||
|
||||
Args:
|
||||
center: center of the viewport in paper space units
|
||||
size: viewport size as (width, height) tuple in paper space units
|
||||
|
||||
"""
|
||||
viewport = self.main_viewport()
|
||||
if viewport is None:
|
||||
viewport = self.add_new_main_viewport()
|
||||
default_center, default_size = self.default_viewport_config()
|
||||
if center is None:
|
||||
center = default_center
|
||||
if size is None:
|
||||
size = default_size
|
||||
|
||||
viewport.dxf.center = center
|
||||
width, height = size
|
||||
viewport.dxf.width = width
|
||||
viewport.dxf.height = height
|
||||
return viewport
|
||||
|
||||
def default_viewport_config(
|
||||
self,
|
||||
) -> tuple[tuple[float, float], tuple[float, float]]:
|
||||
dxf = self.dxf_layout.dxf
|
||||
if dxf.plot_paper_units == 0: # inches
|
||||
unit_factor = 25.4
|
||||
else: # mm
|
||||
unit_factor = 1.0
|
||||
|
||||
# all paper parameters in mm!
|
||||
# all viewport parameters in paper space units inch/mm + scale factor!
|
||||
scale_factor = dxf.scale_denominator / dxf.scale_numerator
|
||||
|
||||
def paper_units(value):
|
||||
return value / unit_factor * scale_factor
|
||||
|
||||
paper_width = paper_units(dxf.paper_width)
|
||||
paper_height = paper_units(dxf.paper_height)
|
||||
# plot origin offset
|
||||
x_offset = paper_units(dxf.plot_origin_x_offset)
|
||||
y_offset = paper_units(dxf.plot_origin_y_offset)
|
||||
|
||||
# printing area
|
||||
printable_width = (
|
||||
paper_width - paper_units(dxf.left_margin) - paper_units(dxf.right_margin)
|
||||
)
|
||||
printable_height = (
|
||||
paper_height - paper_units(dxf.bottom_margin) - paper_units(dxf.top_margin)
|
||||
)
|
||||
|
||||
# AutoCAD viewport (window) size
|
||||
vp_width = paper_width * 1.1
|
||||
vp_height = paper_height * 1.1
|
||||
|
||||
# center of printing area
|
||||
center = (
|
||||
printable_width / 2 - x_offset,
|
||||
printable_height / 2 - y_offset,
|
||||
)
|
||||
return center, (vp_width, vp_height)
|
||||
|
||||
def add_new_main_viewport(self) -> Viewport:
|
||||
"""Add a new main viewport."""
|
||||
center, size = self.default_viewport_config()
|
||||
vp_height = size[1]
|
||||
# create 'main' viewport
|
||||
main_viewport = self.add_viewport(
|
||||
center=center, # no influence to 'main' viewport?
|
||||
size=size, # I don't get it, just use paper size!
|
||||
view_center_point=center, # same as center
|
||||
view_height=vp_height, # view height in paper space units
|
||||
status=1, # main viewport
|
||||
)
|
||||
if len(self.entity_space) > 1:
|
||||
# move main viewport to index 0 of entity space
|
||||
_vp = self.entity_space.pop()
|
||||
assert _vp is main_viewport
|
||||
self.entity_space.insert(0, main_viewport)
|
||||
|
||||
main_viewport.dxf.id = 1 # set as main viewport
|
||||
main_viewport.dxf.flags = 557088 # AutoCAD default value
|
||||
self.set_current_viewport_handle(main_viewport.dxf.handle)
|
||||
return main_viewport
|
||||
|
||||
def set_current_viewport_handle(self, handle: str) -> None:
|
||||
self.dxf_layout.dxf.viewport_handle = handle
|
||||
|
||||
def page_setup(
|
||||
self,
|
||||
size: tuple[float, float] = (297, 210),
|
||||
margins: tuple[float, float, float, float] = (0, 0, 0, 0),
|
||||
units: str = "mm",
|
||||
offset: tuple[float, float] = (0, 0),
|
||||
rotation: int = 0,
|
||||
scale: Union[int, tuple[float, float]] = 16,
|
||||
name: str = "ezdxf",
|
||||
device: str = "DWG to PDF.pc3",
|
||||
) -> None:
|
||||
"""Setup plot settings and paper size and reset viewports.
|
||||
All parameters in given `units` (mm or inch).
|
||||
|
||||
Reset paper limits, extents and viewports.
|
||||
|
||||
Args:
|
||||
size: paper size as (width, height) tuple
|
||||
margins: (top, right, bottom, left) hint: clockwise
|
||||
units: "mm" or "inch"
|
||||
offset: plot origin offset is 2D point
|
||||
rotation: see table Rotation
|
||||
scale: integer in range [0, 32] defines a standard scale type or
|
||||
as tuple(numerator, denominator) e.g. (1, 50) for scale 1:50
|
||||
name: paper name prefix "{name}_({width}_x_{height}_{unit})"
|
||||
device: device .pc3 configuration file or system printer name
|
||||
|
||||
=== ============
|
||||
int Rotation
|
||||
=== ============
|
||||
0 no rotation
|
||||
1 90 degrees counter-clockwise
|
||||
2 upside-down
|
||||
3 90 degrees clockwise
|
||||
=== ============
|
||||
|
||||
"""
|
||||
if int(rotation) not in (0, 1, 2, 3):
|
||||
raise const.DXFValueError("valid rotation values: 0-3")
|
||||
|
||||
if isinstance(scale, tuple):
|
||||
standard_scale = 16
|
||||
scale_num, scale_denom = scale
|
||||
elif isinstance(scale, int):
|
||||
standard_scale = scale
|
||||
scale_num, scale_denom = const.STD_SCALES.get(standard_scale, (1.0, 1.0))
|
||||
else:
|
||||
raise const.DXFTypeError(
|
||||
"Scale has to be an int or a tuple(numerator, denominator)"
|
||||
)
|
||||
if scale_num == 0:
|
||||
raise const.DXFValueError("Scale numerator can't be 0.")
|
||||
if scale_denom == 0:
|
||||
raise const.DXFValueError("Scale denominator can't be 0.")
|
||||
paper_width, paper_height = size
|
||||
margin_top, margin_right, margin_bottom, margin_left = margins
|
||||
units = units.lower()
|
||||
if units.startswith("inch"):
|
||||
units = "Inches"
|
||||
plot_paper_units = 0
|
||||
unit_factor = 25.4 # inch to mm
|
||||
elif units == "mm":
|
||||
units = "MM"
|
||||
plot_paper_units = 1
|
||||
unit_factor = 1.0
|
||||
else:
|
||||
raise const.DXFValueError('Supported units: "mm" and "inch"')
|
||||
|
||||
# Setup PLOTSETTINGS
|
||||
# all paper sizes in mm
|
||||
dxf = self.dxf_layout.dxf
|
||||
if not dxf.hasattr("plot_layout_flags"):
|
||||
dxf.plot_layout_flags = dxf.get_default("plot_layout_flags")
|
||||
self.use_standard_scale(False) # works best, don't know why
|
||||
dxf.page_setup_name = ""
|
||||
dxf.plot_configuration_file = device
|
||||
dxf.paper_size = f"{name}_({paper_width:.2f}_x_{paper_height:.2f}_{units})"
|
||||
dxf.left_margin = margin_left * unit_factor
|
||||
dxf.bottom_margin = margin_bottom * unit_factor
|
||||
dxf.right_margin = margin_right * unit_factor
|
||||
dxf.top_margin = margin_top * unit_factor
|
||||
dxf.paper_width = paper_width * unit_factor
|
||||
dxf.paper_height = paper_height * unit_factor
|
||||
dxf.scale_numerator = scale_num
|
||||
dxf.scale_denominator = scale_denom
|
||||
dxf.plot_paper_units = plot_paper_units
|
||||
dxf.plot_rotation = rotation
|
||||
|
||||
x_offset, y_offset = offset
|
||||
dxf.plot_origin_x_offset = x_offset * unit_factor # conversion to mm
|
||||
dxf.plot_origin_y_offset = y_offset * unit_factor # conversion to mm
|
||||
dxf.standard_scale_type = standard_scale
|
||||
dxf.unit_factor = 1.0 / unit_factor # 1/1 for mm; 1/25.4 ... for inch
|
||||
|
||||
# Setup Layout
|
||||
self.reset_paper_limits()
|
||||
self.reset_extents()
|
||||
self.reset_viewports()
|
||||
|
||||
def reset_paper_limits(self) -> None:
|
||||
"""Set paper limits to default values, all values in paperspace units
|
||||
but without plot scale (?).
|
||||
|
||||
"""
|
||||
dxf = self.dxf_layout.dxf
|
||||
if dxf.plot_paper_units == 0: # inch
|
||||
unit_factor = 25.4
|
||||
else: # mm
|
||||
unit_factor = 1.0
|
||||
|
||||
# all paper sizes are stored in mm
|
||||
paper_width = dxf.paper_width / unit_factor # in plot paper units
|
||||
paper_height = dxf.paper_height / unit_factor # in plot paper units
|
||||
left_margin = dxf.left_margin / unit_factor
|
||||
bottom_margin = dxf.bottom_margin / unit_factor
|
||||
x_offset = dxf.plot_origin_x_offset / unit_factor
|
||||
y_offset = dxf.plot_origin_y_offset / unit_factor
|
||||
# plot origin is the lower left corner of the printable paper area
|
||||
# limits are the paper borders relative to the plot origin
|
||||
shift_x = left_margin + x_offset
|
||||
shift_y = bottom_margin + y_offset
|
||||
dxf.limmin = (-shift_x, -shift_y) # paper space units
|
||||
dxf.limmax = (paper_width - shift_x, paper_height - shift_y)
|
||||
|
||||
def get_paper_limits(self) -> tuple[Vec2, Vec2]:
|
||||
"""Returns paper limits in plot paper units, relative to the plot origin.
|
||||
|
||||
plot origin = lower left corner of printable area + plot origin offset
|
||||
|
||||
Returns:
|
||||
tuple (Vec2(x1, y1), Vec2(x2, y2)), lower left corner is (x1, y1),
|
||||
upper right corner is (x2, y2).
|
||||
|
||||
"""
|
||||
return Vec2(self.dxf.limmin), Vec2(self.dxf.limmax)
|
||||
|
||||
def page_setup_r12(
|
||||
self,
|
||||
size: tuple[float, float] = (297, 210),
|
||||
margins: tuple[float, float, float, float] = (0, 0, 0, 0),
|
||||
units: str = "mm",
|
||||
offset: tuple[float, float] = (0, 0),
|
||||
rotation: float = 0,
|
||||
scale: Union[int, tuple[float, float]] = 16,
|
||||
) -> None:
|
||||
# remove existing viewports
|
||||
for viewport in self.viewports():
|
||||
self.delete_entity(viewport)
|
||||
|
||||
if int(rotation) not in (0, 1, 2, 3):
|
||||
raise const.DXFValueError("Valid rotation values: 0-3")
|
||||
|
||||
if isinstance(scale, int):
|
||||
scale_num, scale_denom = const.STD_SCALES.get(scale, (1, 1))
|
||||
else:
|
||||
scale_num, scale_denom = scale
|
||||
|
||||
if scale_num == 0:
|
||||
raise const.DXFValueError("Scale numerator can't be 0.")
|
||||
if scale_denom == 0:
|
||||
raise const.DXFValueError("Scale denominator can't be 0.")
|
||||
|
||||
scale_factor = scale_denom / scale_num
|
||||
|
||||
# TODO: don't know how to set inch or mm mode in R12
|
||||
units = units.lower()
|
||||
if units.startswith("inch"):
|
||||
units = "Inches"
|
||||
plot_paper_units = 0
|
||||
unit_factor = 25.4 # inch to mm
|
||||
elif units == "mm":
|
||||
units = "MM"
|
||||
plot_paper_units = 1
|
||||
unit_factor = 1.0
|
||||
else:
|
||||
raise const.DXFValueError('Supported units: "mm" and "inch"')
|
||||
|
||||
# all viewport parameters are scaled paper space units
|
||||
def paper_units(value):
|
||||
return value * scale_factor
|
||||
|
||||
margin_top = paper_units(margins[0])
|
||||
margin_right = paper_units(margins[1])
|
||||
margin_bottom = paper_units(margins[2])
|
||||
margin_left = paper_units(margins[3])
|
||||
paper_width = paper_units(size[0])
|
||||
paper_height = paper_units(size[1])
|
||||
self.doc.header["$PLIMMIN"] = (0, 0)
|
||||
self.doc.header["$PLIMMAX"] = (paper_width, paper_height)
|
||||
self.doc.header["$PEXTMIN"] = (0, 0, 0)
|
||||
self.doc.header["$PEXTMAX"] = (paper_width, paper_height, 0)
|
||||
|
||||
# printing area
|
||||
printable_width = paper_width - margin_left - margin_right
|
||||
printable_height = paper_height - margin_bottom - margin_top
|
||||
|
||||
# AutoCAD viewport (window) size
|
||||
vp_width = paper_width * 1.1
|
||||
vp_height = paper_height * 1.1
|
||||
|
||||
# center of printing area
|
||||
center = (printable_width / 2, printable_height / 2)
|
||||
|
||||
# create 'main' viewport
|
||||
main_viewport = self.add_viewport(
|
||||
center=center, # no influence to 'main' viewport?
|
||||
size=(vp_width, vp_height), # I don't get it, just use paper size!
|
||||
view_center_point=center, # same as center
|
||||
view_height=vp_height, # view height in paper space units
|
||||
status=1, # main viewport
|
||||
)
|
||||
main_viewport.dxf.id = 1 # set as main viewport
|
||||
main_viewport.dxf.render_mode = 1000 # AutoDesk default (view mode?)
|
||||
|
||||
def get_paper_limits_r12(self) -> tuple[Vec2, Vec2]:
|
||||
"""Returns paper limits in plot paper units."""
|
||||
limmin = self.doc.header.get("$PLIMMIN", (0, 0))
|
||||
limmax = self.doc.header.get("$PLIMMAX", (0, 0))
|
||||
return Vec2(limmin), Vec2(limmax)
|
||||
|
||||
|
||||
def _find_layout_block_record(layout: DXFLayout) -> BlockRecord | None:
|
||||
"""Find and link the lost BLOCK_RECORD for the given LAYOUT entity."""
|
||||
|
||||
def link_layout(block_record: BlockRecord) -> None:
|
||||
logger.info(
|
||||
f"fixing broken links for '{layout.dxf.name}' between {str(layout)} and {str(block_record)}"
|
||||
)
|
||||
layout.dxf.block_record_handle = block_record.dxf.handle
|
||||
block_record.dxf.layout = layout.dxf.handle
|
||||
|
||||
doc = layout.doc
|
||||
assert doc is not None
|
||||
if layout.dxf.name == "Model": # modelspace layout
|
||||
key = make_table_key("*Model_Space")
|
||||
for block_record in doc.tables.block_records:
|
||||
if make_table_key(block_record.dxf.name) == key:
|
||||
link_layout(block_record)
|
||||
return block_record
|
||||
return None
|
||||
|
||||
# paperspace layout
|
||||
search_key = make_table_key("*Paper_Space")
|
||||
paper_space_records = [
|
||||
block_record
|
||||
for block_record in doc.tables.block_records
|
||||
if make_table_key(block_record.dxf.name).startswith(search_key)
|
||||
]
|
||||
|
||||
def search(key):
|
||||
for block_record in paper_space_records:
|
||||
layout_handle = block_record.dxf.get("layout", "0")
|
||||
if doc.entitydb.get(layout_handle) is key:
|
||||
link_layout(block_record)
|
||||
return block_record
|
||||
return None
|
||||
|
||||
# first search all records for the lost record
|
||||
block_record = search(layout)
|
||||
if block_record is None:
|
||||
# link layout to the next orphaned record
|
||||
block_record = search(None)
|
||||
return block_record
|
||||
Reference in New Issue
Block a user