abstract type GeometryEntityStyle

A style that can be used with a GeometryEntity to create a modified entity.

May use (sty::MyStyle)(ent), styled(ent, sty), or MyStyle(ent, style_args...; style_kwargs...) to create a StyledEntity.

A GeometryEntityStyle should implement to_polygons(::MyEntity, ::MyStyle; kwargs...) for any entity type it can be applied to. As a fallback, it can implement to_polygons(::Polygon, ::MyStyle; kwargs...), in which case entities will be converted to polygons before applying the style.

Unless implemented by the style, lowerleft and upperright (and hence bounds) of a styled entity will use the underlying entity's bounds. Similarly, footprint and halo will fall back to using the underlying entity. Exceptions include the NoRender style, in which case the entity is treated as a zero-area Rectangle (ignored in collective bounds calculations), as well as OptionalStyle, in which case the default style is used (in case it has special behavior).

StyledEntity{T, U <: GeometryEntity{T}, S <: GeometryEntityStyle} <: GeometryEntity

GeometryEntity composing another GeometryEntity with a GeometryEntityStyle.

The use of a StyledEntity allows the composition of operations like rounding on geometric entities without committing to a particular representation of those entities.

entity(styled_ent::StyledEntity)

Return the GeometryEntity styled by styled_ent.

style(styled_ent::StyledEntity)

Return the GeometryEntityStyle of styled_ent.

styled(ent, sty)

Return StyledEntity(ent, sty).

unstyled(styled_ent::StyledEntity)

Return the unstyled entity referenced by styled_ent.

If styled_ent.ent is itself a StyledEntity, apply unstyled recursively until the original plain GeometyEntity is found.

unstyled_type(::GeometryEntity)
unstyled_type(::Type{GeometryEntity})

Return the type of the unstyled entity beneath all styles.

Plain <: GeometryEntityStyle

Plain style. Does not affect rendering of the styled entity.

struct MeshSized{T, S} <: GeometryEntityStyle where {T, S <: Real}
    h::T
    α::S
end

Style that annotates a GeometryEntity with a mesh size to use in SolidModel rendering. The generated mesh will include a size field defined as:

mesh size = h * max(s_g, (d/h)^α)

where d is the distance away from the styled entity, and s_g is the global mesh scale parameter specified in MeshingParameters. A smaller value of h will give a finer mesh attached to the styled entity, and a larger value of α will give a more rapid increase in size away from the styled entity.

For α < 0, the size field will use α_default from the MeshingParameters used in rendering.

See also meshsized_entity and SolidModels.MeshingParameters.

meshsized_entity(ent::GeometryEntity, h::T, α::S=-1.0) where {T, S <: Real}

Create a MeshSized entity, specifying a mesh size use in SolidModel rendering. The generated mesh will include a size field defined as:

mesh size = h * max(s_g, (d/h)^α)

where d is the distance away from the styled entity, and s_g is the global mesh scale parameter specified in MeshingParameters. A smaller value of h will give a finer mesh attached to the styled entity, and a larger value of α will give a more rapid increase in size away from the styled entity.

For α < 0, the size field will use α_default from the SolidModels.MeshingParameters used in rendering.

NoRender <: GeometryEntityStyle

Style that marks an entity to be skipped when rendering.

NoRender-styled entities have zero-area bounds and footprint and empty halo.

struct OptionalStyle <: GeometryEntityStyle
    true_style::GeometryEntityStyle
    false_style::GeometryEntityStyle
    flag::Symbol
    default::Bool
end
OptionalStyle(true_style::GeometryEntityStyle, flag::Symbol;
    false_style::GeometryEntityStyle=Plain(), default::Bool=true)

Style that depends on a Boolean rendering option flag with default default.

lowerleft, upperright, bounds, footprint, and halo are forwarded to the underlying entity styled with the default style.

Examples

sty = OptionalStyle(Rounded(1μm), :rounding)
p = Rectangle(4μm, 4μm)
rounded_rect = to_polygons(sty(p))
plain_rect = to_polygons(sty(p), rounding=false)

optional_entity(ent::GeometryEntity, flag::Symbol;
    true_style::GeometryEntityStyle=Plain(), default=true)

Return an entity to be rendered or not based on the rendering option flag.

Example

julia> c = Cell();

julia> ent = optional_entity(Rectangle(2, 2), :optional_entities; default=false);

julia> render!(c, ent);

julia> length(elements(c))
0

julia> render!(c, ent; optional_entities=true);

julia> length(elements(c))
1

struct ToTolerance{T<:Coordinate} <: GeometryEntityStyle
    atol::T
end

Style for rendering an entity to absolute tolerance atol.

Equivalent to passing or overriding the keyword atol when rendering this entity.