keycap-designer 0.1.3__py3-none-any.whl

keycap_designer/.gitignore

@@ -0,0 +1 @@
+_version.py

keycap_designer/__init__.py

@@ -0,0 +1,7 @@
+try:
+    from ._version import version
+    __version_info__ = version
+except ImportError:
+    __version_info__ = version = '0.0.dev1'
+
+__version__ = '.'.join(map(str, __version_info__))

keycap_designer/__main__.py

@@ -0,0 +1,254 @@
+import faulthandler
+faulthandler.enable()
+import typing as ty
+import os
+import subprocess
+from pathlib import Path
+import importlib
+import traceback
+import sys
+import platform
+
+from prompt_toolkit import PromptSession
+from prompt_toolkit.completion import NestedCompleter, PathCompleter
+from prompt_toolkit.history import FileHistory
+from prompt_toolkit.styles import Style
+from prompt_toolkit.shortcuts import yes_no_dialog
+
+from keycap_designer.constants import CURRENT_DIR, RESOURCE_DIR
+from keycap_designer.manuscript import manuscript_to_artwork
+from keycap_designer.preview import print_rc_map, print_preview
+
+
+CONTENT_DIR_NAME = 'content'
+FONT_DIR_NAME = 'font'
+LAYOUT_DIR_NAME = 'layout'
+VSCODE_DIR_NAME = '.vscode'
+CONTENT_DIR = CURRENT_DIR / CONTENT_DIR_NAME
+OUTPUT_DIR = CURRENT_DIR / 'tmp'
+REPO_DIR_NAMES = [CONTENT_DIR_NAME, FONT_DIR_NAME, LAYOUT_DIR_NAME]
+REPO_DIRS = [CURRENT_DIR / d for d in REPO_DIR_NAMES]
+MODULE = None
+IMPORTED_MODULE_D: dict[str, ty.Any] = {}
+
+
+style = Style.from_dict({
+    'module_name': '#00dd00',
+    'pound': 'ansicyan',
+    'sheet_size': '#884444',
+    'separator': '#0000aa',
+    'status': '#aa0000',
+})
+session = PromptSession(history=FileHistory('history.txt'), style=style)
+
+
+def show_pdf(pdf: Path):
+    s = platform.system()
+    if s == 'Darwin':
+        import shlex
+        subprocess.Popen([f'open {shlex.quote(str(pdf))}'], shell=True)
+    elif s == 'Windows':
+        subprocess.Popen([str(pdf)], shell=True)
+    else:
+        print(f'Platform {s} is not supported. Open {str(pdf)} by yourself.')
+
+
+def show_preview():
+    if MODULE is None:
+        raise Exception('show_preview called but MODULE is None.')
+    if not hasattr(MODULE, 'CONTENT'):
+        print(f"Error: {MODULE.__name__} doesn't have CONTENT.")
+        return
+
+    pdf = OUTPUT_DIR / f'{MODULE.__name__}_preview.pdf'
+    try:
+        print_preview([manuscript_to_artwork(i) for i in MODULE.CONTENT], pdf)
+    except PermissionError:
+        print('Error: Close the PDF file.')
+        return
+    except FileNotFoundError as e:
+        print(f'File not found: {str(e)}')
+        return
+    except Exception as e:
+        print('Error: show_preview failed. Exception:')
+        traceback.print_exception(e)
+        return
+    show_pdf(pdf)
+
+
+def rc_map(text: str):
+    layout_fn = text.split()[1]
+    p = Path(CURRENT_DIR / LAYOUT_DIR_NAME / layout_fn)
+    pdf = OUTPUT_DIR / f'{p.stem}_rc_map.pdf'
+    try:
+        print_rc_map(p, pdf)
+    except PermissionError:
+        print('Error: Close the PDF file.')
+        return
+    except Exception as e:
+        print('Error: rc_map failed. Exception:')
+        traceback.print_exception(e)
+        return
+    show_pdf(pdf)
+
+
+def reload():
+    global MODULE
+    if MODULE is None:
+        print('Error: content not loaded yet.')
+        return
+    try:
+        MODULE = importlib.reload(MODULE)
+        IMPORTED_MODULE_D[MODULE.__name__] = MODULE
+    except Exception as e:
+        print(f'Error: {MODULE.__name__} reload failed. Exception:')
+        traceback.print_exception(e)
+        MODULE = None
+        return
+    if not hasattr(MODULE, 'CONTENT'):
+        print(f"Error: {MODULE.__name__} doesn't have CONTENT.")
+        MODULE = None
+        return
+    show_preview()
+
+
+def load(text: str):
+    global MODULE
+    fn = text.split()[1]
+    p = Path(CONTENT_DIR / fn).relative_to(CONTENT_DIR)
+    module_name = str.join('.', (CONTENT_DIR_NAME, ) + p.parts[:-1] + (p.stem, ))
+    importlib.invalidate_caches()
+    try:
+        if module_name in IMPORTED_MODULE_D:
+            MODULE = importlib.reload(IMPORTED_MODULE_D[module_name])
+        else:
+            MODULE = importlib.import_module(module_name)
+    except Exception as e:
+        MODULE = None
+        print(f'Error: {module_name} import failed. Exception:')
+        traceback.print_exception(e)
+        return
+    IMPORTED_MODULE_D[module_name] = MODULE
+    if not hasattr(MODULE, 'CONTENT'):
+        print(f"Error: {module_name} doesn't have CONTENT.")
+        MODULE = None
+        return
+    show_preview()
+    return
+
+
+def remove_file_if_exists(p: Path):
+    if not p.exists():
+        return True
+    try:
+        p.unlink()
+    except Exception:
+        return False
+    return True
+
+
+def pump():
+    module_path_completer = PathCompleter(get_paths=lambda: [CONTENT_DIR_NAME], file_filter=lambda fn: os.path.isdir(fn) or fn.endswith('.py'))
+    layout_path_completer = PathCompleter(get_paths=lambda: [LAYOUT_DIR_NAME], file_filter=lambda fn: os.path.isdir(fn) or fn.endswith('.json'))
+    root_completer = NestedCompleter.from_nested_dict({
+        'show': None,
+        'reload': None,
+        'load': module_path_completer,
+        'rc_map': layout_path_completer,
+        'help': None,
+        'exit': None
+    })
+
+    message = []
+
+    message += [
+        ('class:module_name', '('),
+        ('class:module_name', 'None' if MODULE is None else MODULE.__name__),
+        ('class:module_name', ')'),
+    ]
+
+    message.append(('class:pound', '# '))
+
+    text: str = session.prompt(message, completer=root_completer, bottom_toolbar='To exit this app, type "exit" and hit Enter key.')
+
+    if text == 'show':
+        show_preview()
+    if text.startswith('rc_map'):
+        rc_map(text)
+    elif text == '' or text == 'reload':
+        reload()
+    elif text.startswith('load'):
+        load(text)
+    elif text.startswith('exit'):
+        return False
+    elif text.startswith('help'):
+        print('''Commands:
+load {content script file}:
+    Loads the content script and shows the preview.
+reload (or just hit Enter key):
+    Reloads current content script and shows the preview.
+show:
+    Shows the preview of current content script without reloading.
+rc_map {layout KLE JSON file}:
+    Shows Row/Col map of the layout KLE JSON file.
+exit:
+    Exits this app.''')
+    else:
+        print(f'Error: {text} is invalid.')
+
+    return True
+
+
+def repo_ok():
+    if not OUTPUT_DIR.is_dir():
+        if not remove_file_if_exists(OUTPUT_DIR):
+            print(f'Error: Cannot remove {OUTPUT_DIR} file. Please remove the file by yourself.')
+            sys.exit(1)
+        OUTPUT_DIR.mkdir()
+
+    if all(d.is_dir() for d in REPO_DIRS + [CURRENT_DIR / VSCODE_DIR_NAME]):
+        return True
+
+    result = yes_no_dialog(
+        title="keycap-designer",
+        text="Do you initialize current directory for keycap-designer?"
+    ).run()
+
+    if result:
+        import shutil
+        for n, d in zip(REPO_DIR_NAMES, REPO_DIRS):
+            shutil.copytree(RESOURCE_DIR / 'repo' / n, d, dirs_exist_ok=True)
+        shutil.copytree(RESOURCE_DIR / 'repo/vscode', CURRENT_DIR / VSCODE_DIR_NAME, dirs_exist_ok=True)
+
+    return result
+
+
+def main():
+    from keycap_designer import version
+    print(f'keycap-designer {version} (C) 2023-2025 DecentKeyboards; MIT License')
+    if not repo_ok():
+        return
+    if len(sys.argv) > 1:
+        v = sys.argv[1]
+        try:
+            vp = Path(v)
+        except Exception:
+            print('Error: The arg {v} is not a valid file path.')
+            sys.exit(1)
+        try:
+            rp = vp.relative_to(CONTENT_DIR)
+        except Exception:
+            print('Error: The file {v} is not in ./content folder.')
+            sys.exit(1)
+        load('load ' + str(rp))
+        
+    sys.path.append(os.getcwd())
+    print('Type "help" and hit Enter key to show the command help.')
+    while True:
+        cont = pump()
+        if not cont:
+            break
+
+
+if __name__ == '__main__':
+    main()

keycap_designer/_version.py

@@ -0,0 +1,21 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.1.3'
+__version_tuple__ = version_tuple = (0, 1, 3)

keycap_designer/area/junana/note.txt

@@ -0,0 +1,5 @@
+Margin line width should be 1 pt.
+
+For top side, the inner edge of the margin line should be the surface edge of the top side. The fillets are not included.
+
+For front side, margin line should be placed on the edge of fillet-less surface. The projection angle is 60 degree.

keycap_designer/color_management.py

@@ -0,0 +1,176 @@
+import typing as ty
+from enum import Enum, auto
+from dataclasses import dataclass
+from pathlib import Path
+import numpy as np
+from numpy.typing import NDArray
+from PIL import Image as PILImageModule
+import cv2
+import cmm
+from .overwrite_reportlab import overwrite_reportlab
+
+ICC_DIR = Path(__file__).parent / 'icc'
+WORKSPACE_PROFILE_PATH = ICC_DIR / 'Linear P3D65.icc'
+WS_HP = None
+with open(ICC_DIR / 'sRGBz.icc', 'rb') as f:
+    SRGB_PROF = f.read()
+overwrite_reportlab()
+
+
+class RenderingIntent(Enum):
+    Perceptual = cmm.INTENT_PERCEPTUAL
+    Relative = cmm.INTENT_RELATIVE_COLORIMETRIC
+    Saturation = cmm.INTENT_SATURATION
+    Absolute = cmm.INTENT_ABSOLUTE_COLORIMETRIC
+
+
+class _ColorSpaceType(Enum):
+    SRGB = auto()
+    WORKSPACE = auto()
+    DEVICE_RGB = auto()
+    DEVICE_RGB_16 = auto()
+
+
+_CST_FMT = {
+    _ColorSpaceType.SRGB: cmm.get_transform_formatter(0, cmm.PT_RGB, 3, 1, 0, 0),
+    _ColorSpaceType.WORKSPACE: cmm.get_transform_formatter(0, cmm.PT_RGB, 3, 2, 0, 0),
+    _ColorSpaceType.DEVICE_RGB: cmm.get_transform_formatter(0, cmm.PT_RGB, 3, 1, 0, 0),
+    _ColorSpaceType.DEVICE_RGB_16: cmm.get_transform_formatter(0, cmm.PT_RGB, 3, 2, 0, 0)
+}
+
+
+with open(WORKSPACE_PROFILE_PATH, 'rb') as f:
+    WS_HP = cmm.open_profile_from_mem(f.read())
+del f
+
+
+def check_ws_img(ws_img: NDArray[np.uint16]):
+    if ws_img.shape[2] != 3:
+        raise Exception('ws_img should be BGR image')
+
+
+@dataclass(frozen=True)
+class _ColorConversionType:
+    source: _ColorSpaceType
+    target: _ColorSpaceType
+    bpc: bool
+    soft_proof: bool = False
+    soft_proof_cs: _ColorSpaceType = _ColorSpaceType.SRGB
+
+
+class ColorConverter:
+    def __init__(self, device_rgb_profile_path: Path) -> None:
+        self._transform_cache: dict[tuple[_ColorConversionType, RenderingIntent], ty.Any] = {}
+        with open(device_rgb_profile_path, 'rb') as f:
+            hp = cmm.open_profile_from_mem(f.read())
+        self.cst_hp = {
+            _ColorSpaceType.SRGB: cmm.create_srgb_profile(),
+            _ColorSpaceType.WORKSPACE: WS_HP,
+            _ColorSpaceType.DEVICE_RGB: hp,
+            _ColorSpaceType.DEVICE_RGB_16: hp
+        }
+
+    def _get_transform(self, cct: _ColorConversionType, rendering_intent: RenderingIntent):
+        if (cct, rendering_intent) in self._transform_cache:
+            return self._transform_cache[cct, rendering_intent]
+        bpc = cmm.cmsFLAGS_BLACKPOINTCOMPENSATION if cct.bpc else 0
+        if cct.soft_proof:
+            tr = cmm.create_proofing_transform(
+                self.cst_hp[cct.source], _CST_FMT[cct.source],
+                self.cst_hp[cct.soft_proof_cs], _CST_FMT[cct.soft_proof_cs],
+                self.cst_hp[_ColorSpaceType.DEVICE_RGB],
+                rendering_intent.value, cmm.INTENT_RELATIVE_COLORIMETRIC,
+                bpc)
+        else:
+            tr = cmm.create_transform(
+                self.cst_hp[cct.source], _CST_FMT[cct.source],
+                self.cst_hp[cct.target], _CST_FMT[cct.target],
+                rendering_intent.value,
+                bpc)
+        self._transform_cache[cct, rendering_intent] = tr
+        return tr
+
+    def workspace_to_device_rgb(self, ws_img: NDArray[np.uint16], rendering_intent: RenderingIntent, bpc=True):
+        check_ws_img(ws_img)
+        trg_img = np.zeros(ws_img.shape, dtype=np.uint8)
+        tr = self._get_transform(_ColorConversionType(_ColorSpaceType.WORKSPACE, _ColorSpaceType.DEVICE_RGB, bpc), rendering_intent)
+        cmm.do_transform_16_8(tr, cv2.cvtColor(ws_img, cv2.COLOR_BGR2RGB), trg_img, ws_img.size // 3)
+        return PILImageModule.fromarray(trg_img)
+
+    def workspace_to_device_rgb_as_cv2(self, ws_img: NDArray[np.uint16], rendering_intent: RenderingIntent, bpc=True) -> NDArray[np.uint16]:
+        check_ws_img(ws_img)
+        trg_img = np.zeros(ws_img.shape, dtype=np.uint16)
+        tr = self._get_transform(_ColorConversionType(_ColorSpaceType.WORKSPACE, _ColorSpaceType.DEVICE_RGB_16, bpc), rendering_intent)
+        cmm.do_transform_16_16(tr, cv2.cvtColor(ws_img, cv2.COLOR_BGR2RGB), trg_img, ws_img.size // 3)
+        return cv2.cvtColor(trg_img, cv2.COLOR_RGB2BGR)  # type: ignore
+
+    def device_rgb_as_cv2_to_workspace(self, device_rgb_img: NDArray[np.uint16]) -> NDArray[np.uint16]:
+        trg_img = np.zeros(device_rgb_img.shape, dtype=np.uint16)
+        tr = self._get_transform(_ColorConversionType(_ColorSpaceType.DEVICE_RGB_16, _ColorSpaceType.WORKSPACE, False), RenderingIntent.Relative)
+        cmm.do_transform_16_16(tr, cv2.cvtColor(device_rgb_img, cv2.COLOR_BGR2RGB), trg_img, device_rgb_img.size // 3)
+        return cv2.cvtColor(trg_img, cv2.COLOR_RGB2BGR)  # type: ignore
+
+    def source_to_workspace(self, pil_img: PILImageModule.Image) -> NDArray[np.uint16]:
+        src_fmt = cmm.get_transform_formatter(0, cmm.PT_RGB, 3, 1, 0, 0)
+        src_hp = None
+        if 'icc_profile' in pil_img.info:
+            profile_mem = pil_img.info['icc_profile']
+            src_hp = cmm.open_profile_from_mem(profile_mem)
+            tr = cmm.create_transform(
+                src_hp, src_fmt,
+                self.cst_hp[_ColorSpaceType.WORKSPACE], _CST_FMT[_ColorSpaceType.WORKSPACE],
+                cmm.INTENT_RELATIVE_COLORIMETRIC, 0)
+        else:
+            tr = self._get_transform(_ColorConversionType(_ColorSpaceType.SRGB, _ColorSpaceType.WORKSPACE, False), RenderingIntent.Relative)
+        src_img = np.array(pil_img.convert('RGB'))
+        trg_img = np.zeros(src_img.shape, dtype=np.uint16)
+        cmm.do_transform_8_16(tr, src_img, trg_img, src_img.size // 3)
+        if src_hp is not None:
+            cmm.close_profile(src_hp)
+        ret = cv2.cvtColor(trg_img, cv2.COLOR_RGB2BGR)
+        if 'A' in pil_img.mode:
+            ret = cv2.cvtColor(ret, cv2.COLOR_BGR2BGRA)
+            ret[:, :, 3] = np.array(pil_img.getchannel('A'), np.uint16) * 257
+        return ret  # type: ignore
+
+    def workspace_to_soft_proof(self, ws_img: NDArray[np.uint16], rendering_intent: RenderingIntent, bpc=True):
+        '''
+        The result is sRGB.
+        '''
+        check_ws_img(ws_img)
+        trg_img = np.zeros(ws_img.shape, dtype=np.uint8)
+        tr = self._get_transform(_ColorConversionType(_ColorSpaceType.WORKSPACE, _ColorSpaceType.DEVICE_RGB, bpc, soft_proof=True), rendering_intent)
+        cmm.do_transform_16_8(tr, cv2.cvtColor(ws_img, cv2.COLOR_BGR2RGB), trg_img, ws_img.size // 3)
+        pimg = PILImageModule.fromarray(trg_img)
+        pimg.info['icc_profile'] = SRGB_PROF
+        return pimg
+
+    def workspace_to_soft_proof_as_workspace(self, ws_img: NDArray[np.uint16], rendering_intent: RenderingIntent, bpc=True) -> NDArray[np.uint16]:
+        check_ws_img(ws_img)
+        trg_img = np.zeros(ws_img.shape, dtype=np.uint16)
+        tr = self._get_transform(_ColorConversionType(_ColorSpaceType.WORKSPACE, _ColorSpaceType.DEVICE_RGB, bpc, soft_proof=True, soft_proof_cs=_ColorSpaceType.WORKSPACE), rendering_intent)
+        cmm.do_transform_16_16(tr, cv2.cvtColor(ws_img, cv2.COLOR_BGR2RGB), trg_img, ws_img.size // 3)
+        return cv2.cvtColor(trg_img, cv2.COLOR_RGB2BGR)  # type: ignore
+
+    def workspace_to_srgb_as_cv2(self, ws_img: NDArray[np.uint16]) -> NDArray[np.uint8]:
+        check_ws_img(ws_img)
+        trg_img = np.zeros(ws_img.shape, dtype=np.uint8)
+        tr = self._get_transform(_ColorConversionType(_ColorSpaceType.WORKSPACE, _ColorSpaceType.SRGB, False), RenderingIntent.Relative)
+        cmm.do_transform_16_8(tr, cv2.cvtColor(ws_img, cv2.COLOR_BGR2RGB), trg_img, ws_img.size // 3)
+        return cv2.cvtColor(trg_img, cv2.COLOR_RGB2BGR)  # type: ignore
+
+    def workspace_to_srgb(self, ws_img: NDArray[np.uint16]):
+        '''
+        For debugging.
+        '''
+        if ws_img.shape[2] == 4:
+            ws_img = ws_img[:, :, :3]
+        trg_img = np.zeros(ws_img.shape, dtype=np.uint8)
+        tr = self._get_transform(_ColorConversionType(_ColorSpaceType.WORKSPACE, _ColorSpaceType.SRGB, False), RenderingIntent.Relative)
+        cmm.do_transform_16_8(tr, cv2.cvtColor(ws_img, cv2.COLOR_BGR2RGB), trg_img, ws_img.size // 3)
+        pimg = PILImageModule.fromarray(trg_img)
+        pimg.info['icc_profile'] = SRGB_PROF
+        return pimg
+
+
+DEFAULT_CC = ColorConverter(ICC_DIR / 'sublinova-epson4pigment-PBT-20231121_srgb.icc')

keycap_designer/constants.py

@@ -0,0 +1,75 @@
+from enum import Enum, auto
+from pathlib import Path
+import os
+import platform
+from ordered_enum.ordered_enum import OrderedEnum
+
+
+class Orientation(Enum):
+    LeftTop = auto()
+    Center = auto()
+    RightBottom = auto()
+
+
+Left = Orientation.LeftTop
+Center = Orientation.Center
+Right = Orientation.RightBottom
+Top = Left
+Bottom = Right
+
+
+class ImageFit(Enum):
+    KeepAspect = auto()
+    Crop = auto()
+    Expand = auto()
+    PixelWise = auto()
+
+
+Aspect = ImageFit.KeepAspect
+Crop = ImageFit.Crop
+Expand = ImageFit.Expand
+PixelWise = ImageFit.PixelWise
+
+
+class ImageInterpolate(Enum):
+    Cubic = auto()
+    Nearest = auto()
+
+
+Cubic = ImageInterpolate.Cubic
+Nearest = ImageInterpolate.Nearest
+
+
+class ImageTrim(Enum):
+    Inner = auto()
+    Outer = auto()
+
+
+TrimInner = ImageTrim.Inner
+TrimOuter = ImageTrim.Outer
+
+
+class Side(OrderedEnum):
+    Top = auto()
+    Front = auto()
+    TopFront = auto()
+
+
+TopSide = Side.Top
+FrontSide = Side.Front
+
+
+CURRENT_DIR = Path(os.getcwd())
+RESOURCE_DIR = Path(os.path.dirname(__file__))
+OS_FONT_DIR = {
+    'Windows': Path(r'C:\Windows\Fonts'),
+    'Darwin': Path('/Library/Fonts'),
+    'Linux': Path('/usr/share/fonts')
+}[platform.system()]
+APP_FONT_DIR = CURRENT_DIR / 'font'
+DESC_FONT_PATH = RESOURCE_DIR / 'font/NotoSansMono-VariableFont_wdth,wght.ttf'
+DPI = 720
+IPM = 25.4
+DPM = DPI / IPM
+MAX_RANK = 100
+MAX_N_CB = 10

keycap_designer/deform/deform_test.py

@@ -0,0 +1,46 @@
+from importlib import import_module
+from pathlib import Path
+import numpy as np
+from skimage.transform import PiecewiseAffineTransform, warp
+import cv2
+
+
+AREA_NAME = 'f1u_convex'
+DATA_DIR = Path(__file__).parent / "junana"
+AREA = True
+
+d = 'area' if AREA else 'pattern'
+IMG_FILENAME = str(DATA_DIR / f"{d}/{AREA_NAME}.png")
+
+
+image = cv2.imread(IMG_FILENAME, cv2.IMREAD_UNCHANGED)
+if AREA:
+    alpha = image[:, :, 3].copy()
+    image[alpha == 0] = 255
+    image[:, :, 3] = alpha
+else:
+    i = np.full(image.shape[:2] + (4, ), 255, np.uint8)
+    i[:, :, :3] = image
+    image = i
+image[:, :, 3] = 255 - image[:, :, 3]  # type: ignore
+rows, cols = image.shape[:2]
+
+landmarks = import_module(f'junana.{AREA_NAME}').TABLE
+dst = landmarks[:, 0]
+src = landmarks[:, 1]
+if AREA:
+    src, dst = dst, src
+
+out_cols, out_rows = src.max(axis=0)
+
+tform = PiecewiseAffineTransform()
+_ = tform.estimate(src, dst)
+
+out = (warp(image, tform, output_shape=(out_rows, out_cols), cval=0.5) * 255).astype(np.uint8)
+
+out[:, :, 3] = 255 - out[:, :, 3]
+
+cv2.imshow('img', out)
+cv2.waitKey(0)
+cv2.destroyAllWindows()
+cv2.imwrite('tmp/out.png', out)