Software voor ontwerp schaalverdeling paneel meters

#!/bin/python3

import math

def cos(x):
   return math.cos(math.radians(x))

def sin(x):
   return math.sin(math.radians(x))

def Write(s):
   print(s)

class Object:
   pass

Width       = 300
Height      = 150

# Scale parameters
Scale = Object()
Scale.Min          =   0.0
Scale.Max          =   1.0
Scale.Div          =   0.2
Scale.NrDecimals   =   1

Scale.SubDivisions = [ 2, 5]
Scale.Angle        =  90   # Degrees
Scale.Radius       = 140   # pixels
Scale.Caption      = "A"

def SvgFont():
   return f'font-size="16" fill="black" style="font-family:Serif" '

DoPointer = False

# Draw meter x on the screen
def DrawMeter():

   Write(f'<svg xmlns="http://www.w3.org/2000/svg" version="1.1" width="{Width}" height="{Height}">')

   # Define clipping area
   Write(f'<clipPath id="MyScaleBoundary">')
   Write(f'   <rect x="0" y="0" width="{Width}" height="{Height}"/>')
   Write(f'</clipPath>')

   # Set clippath because IE does not clip svg viewport by default
   Write(f'<g clip-path="url(#MyScaleBoundary)" stroke="black" stroke-width="1" fill="white">')

   # Draw panelmeter border with rouded corners
   Write(f'   <rect x="1" y="1" width="{Width - 2}" height="{Height - 2}" rx="20" ry="20"/>')

   r  = Scale.Radius       # Scale radius
   cx = Width / 2          # Circle center x
   cy = 60 + Scale.Radius  # Circle center y

   def SvgRotate(Angle):
      return f'transform="rotate({Angle} {cx} {cy})"'

   def SvgArcPos(Angle):
      x = cx + sin(Angle) * r
      y = cy - cos(Angle) * r
      return f'{x},{y}'

   Write(f'   <g fill="black" stroke="black">')

   # Scale baseline
   Write(f'      <path d="M {SvgArcPos(-Scale.Angle/2)} A {r} {r} 0 0,1 {SvgArcPos(+Scale.Angle/2)}" fill="none"/>')

   # -- Scale divisions
   Delta  = (Scale.Angle / ((Scale.Max - Scale.Min) / Scale.Div) ) # Degrees per divison
   Delta /= (Scale.SubDivisions[0] * Scale.SubDivisions[1])        # Degrees per SubSubdivision

   Count1 = 0
   Count2 = 0
   Dial = Scale.Min

   Angle = - Scale.Angle / 2
   while(True):
      if(Angle > (Scale.Angle / 2) + 0.01):
         break;

      if (Count1 == 0):
         Write(f'      <path d="M {cx},{cy-r} V {cy-r-15}" {SvgRotate(Angle)} />')
         Write(f'      <text x="{cx}" y="{cy-r-20}" text-anchor="middle" {SvgRotate(Angle)} {SvgFont()}>{Dial:.{Scale.NrDecimals}f}</text>')
         Dial += Scale.Div

      elif(Count2 == 0):
         Write(f'      <path d="M {cx},{cy-r} V {cy-r-10}" {SvgRotate(Angle)}/>')

      else:
         Write(f'      <path d="M {cx},{cy-r} V {cy-r-5}"  {SvgRotate(Angle)}/>')

      if(Count1 == 0):
         Count1 = Scale.SubDivisions[0] * Scale.SubDivisions[1]

      if(Count2 == 0):
         Count2 = Scale.SubDivisions[1]

      Count1 -= 1
      Count2 -= 1
      Angle  += Delta

   Write(f'   </g>')

   # Write Label Text in the meter
   Write(f'   <text x="{cx}" y="{cy-r+40}" text-anchor="middle" fill="black">{Scale.Caption}</text>')

   if(DoPointer):
      # Draw a Pointer with Arrow-Head
      Write(f'   <g transform="rotate(-45 {cx} {cy})">')
      Write(f'      <path d="M {cx},{cy} V {cy-r+5}"/>')
      Write(f'      <polygon points="{cx},65 {cx-5},95 {cx+5},95"/>')
      Write(f'   </g>')
      Write(f'   <circle cx="{cx}" cy="{cy}" r="60" fill="black" />')

   Write(f'</g>')
   Write(f'</svg>')

DrawMeter()

Width       = 300
Height      = 150

# Scale parameters
Scale = Object()
Scale.Min          =   0.0
Scale.Max          =   1.0
Scale.Div          =   0.2
Scale.NrDecimals   =   1

Scale.SubDivisions = [ 2, 5]
Scale.Angle        =  90   # Degrees
Scale.Radius       = 140   # pixels
Scale.Caption      = "A"

#!/bin/python3

import math
import os
import ezdxf

# Visual Parameters
CHAR_SCALE = 8.0               # Height of one character
CHAR_THICKNESS = 1              # Thickness of segments

TICK_THICKNESS = 0.4
TICK_LENGTH_MAJOR = 15
TICK_LENGTH_MEDIUM = 10
TICK_LENGTH_MINOR = 5
TEXT_OFFSET_X = 6
TEXT_OFFSET_Y = 2
TEXT_SPACING = 1.6             # Multiplier for character spacing

# Output
script_dir = os.path.dirname(os.path.abspath(__file__))
output_path = os.path.join(script_dir, "output.dxf")

Width = 50
Height = 25

# Scale settings
class Scale:
    Min = 0.0
    Max = 1.0
    Div = 0.2
    NrDecimals = 1
    SubDivisions = [2, 5]
    Angle = 90
    Radius = 140
    Caption = "A"

# Setup
doc = ezdxf.new()
msp = doc.modelspace()

r = Scale.Radius
cx = Width / 2
cy = 60  # center

def polar(angle_deg, radius):
    a = math.radians(angle_deg)
    return cx + math.sin(a) * radius, cy + math.cos(a) * radius

def draw_solid_line(msp, x1, y1, x2, y2, thickness=TICK_THICKNESS):
    dx = x2 - x1
    dy = y2 - y1
    length = math.hypot(dx, dy)
    if length == 0:
        return
    ux = dx / length
    uy = dy / length
    nx = -uy * (thickness / 2)
    ny = ux * (thickness / 2)

    p1 = (x1 + nx, y1 + ny)
    p2 = (x1 - nx, y1 - ny)
    p3 = (x2 - nx, y2 - ny)
    p4 = (x2 + nx, y2 + ny)

    msp.add_lwpolyline([p1, p2, p3, p4, p1], close=True)

def draw_segment(msp, x1, y1, x2, y2, thickness):
    dx = x2 - x1
    dy = y2 - y1
    full_length = math.hypot(dx, dy)
    if full_length == 0:
        return

    ux = dx / full_length
    uy = dy / full_length
    nx = -uy * (thickness / 2)
    ny = ux * (thickness / 2)

    tip = thickness * 0.6
    shorten = thickness

    sx1 = x1 + ux * shorten
    sy1 = y1 + uy * shorten
    sx2 = x2 - ux * shorten
    sy2 = y2 - uy * shorten

    p1 = (sx1 + nx, sy1 + ny)
    p2 = (sx1 - nx, sy1 - ny)
    p3 = (sx2 - nx, sy2 - ny)
    p4 = (sx2 + nx, sy2 + ny)

    tip1 = (sx1 - ux * tip, sy1 - uy * tip)
    tip2 = (sx2 + ux * tip, sy2 + uy * tip)

    points = [tip1, p1, p4, tip2, p3, p2, tip1]
    msp.add_lwpolyline(points, close=True)

def draw_seg_a(msp, x, y, scale, thickness): draw_segment(msp, x, y + 2*scale, x + scale, y + 2*scale, thickness)
def draw_seg_b(msp, x, y, scale, thickness): draw_segment(msp, x + scale, y + 2*scale, x + scale, y + scale, thickness)
def draw_seg_c(msp, x, y, scale, thickness): draw_segment(msp, x + scale, y + scale, x + scale, y, thickness)
def draw_seg_d(msp, x, y, scale, thickness): draw_segment(msp, x, y, x + scale, y, thickness)
def draw_seg_e(msp, x, y, scale, thickness): draw_segment(msp, x, y + scale, x, y, thickness)
def draw_seg_f(msp, x, y, scale, thickness): draw_segment(msp, x, y + 2*scale, x, y + scale, thickness)
def draw_seg_g(msp, x, y, scale, thickness): draw_segment(msp, x, y + scale, x + scale, y + scale, thickness)
def draw_seg_dp(msp, x, y, scale, thickness): msp.add_circle((x, y), thickness * scale * 0.2)

segment_lookup = {
    'A': draw_seg_a,
    'B': draw_seg_b,
    'C': draw_seg_c,
    'D': draw_seg_d,
    'E': draw_seg_e,
    'F': draw_seg_f,
    'G': draw_seg_g,
    'DP': draw_seg_dp,
}

char_segments = {
    '0': (['A', 'B', 'C', 'D', 'E', 'F'], 1.0),
    '1': (['B', 'C'], 1.0),
    '2': (['A', 'B', 'G', 'E', 'D'], 1.0),
    '3': (['A', 'B', 'G', 'C', 'D'], 1.0),
    '4': (['F', 'G', 'B', 'C'], 1.0),
    '5': (['A', 'F', 'G', 'C', 'D'], 1.0),
    '6': (['A', 'F', 'G', 'E', 'C', 'D'], 1.0),
    '7': (['A', 'B', 'C'], 1.0),
    '8': (['A', 'B', 'C', 'D', 'E', 'F', 'G'], 1.0),
    '9': (['A', 'B', 'C', 'D', 'F', 'G'], 1.0),
    '-': (['G'], 1.0),
    '.': (['DP'], 0.4),  # Much narrower width
}

def draw_char_segments(msp, ch, x, y):
    segments, _ = char_segments.get(ch, ([], 1.0))
    for seg in segments:
        func = segment_lookup[seg]
        func(msp, x, y, CHAR_SCALE, CHAR_THICKNESS)

def draw_text(msp, text, x, y):
    pos = x
    for ch in text:
        segments, width = char_segments.get(ch, ([], 1.0))
        draw_char_segments(msp, ch, pos, y)
        pos += CHAR_SCALE * TEXT_SPACING * width

def draw_meter():
    Delta = Scale.Angle / ((Scale.Max - Scale.Min) / Scale.Div)
    Delta /= (Scale.SubDivisions[0] * Scale.SubDivisions[1])

    Count1 = 0
    Count2 = 0
    Dial = Scale.Min
    Angle = -Scale.Angle / 2

    while Angle <= (Scale.Angle / 2 + 0.01):
        x1, y1 = polar(Angle, r)
        if Count1 == 0:
            x2, y2 = polar(Angle, r + TICK_LENGTH_MAJOR)
            draw_solid_line(msp, x1, y1, x2, y2)
            xt, yt = polar(Angle, r + 35)
            draw_text(msp, f"{Dial:.{Scale.NrDecimals}f}", xt - TEXT_OFFSET_X, yt + TEXT_OFFSET_Y)
            Dial += Scale.Div
        elif Count2 == 0:
            x2, y2 = polar(Angle, r + TICK_LENGTH_MEDIUM)
            draw_solid_line(msp, x1, y1, x2, y2)
        else:
            x2, y2 = polar(Angle, r + TICK_LENGTH_MINOR)
            draw_solid_line(msp, x1, y1, x2, y2)

        if Count1 == 0:
            Count1 = Scale.SubDivisions[0] * Scale.SubDivisions[1]
        if Count2 == 0:
            Count2 = Scale.SubDivisions[1]

        Count1 -= 1
        Count2 -= 1
        Angle += Delta

    draw_text(msp, Scale.Caption, cx - TEXT_OFFSET_X, cy + r + 30)

# Run
draw_meter()
doc.saveas(output_path)
print(f"DXF saved to: {output_path}")