conversor3mf 0.1.0__py3-none-any.whl

conversor3mf/__main__.py

@@ -0,0 +1,111 @@
+"""Linha de comando: python -m conversor3mf <comando> ..."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from . import ace as modulo_ace
+from . import ilhas
+from .conversor import converter, planejar
+from .projeto import ler_projeto
+from .verificar import verificar
+
+
+def _mapa(texto: str | None) -> dict[int, int]:
+    """'1=3,2=1' -> {1: 3, 2: 1}"""
+    if not texto:
+        return {}
+    mapa = {}
+    for par in texto.split(","):
+        origem, _, slot = par.partition("=")
+        mapa[int(origem)] = int(slot)
+    return mapa
+
+
+def _mostrar(dados) -> None:
+    print(json.dumps(dados, indent=2, ensure_ascii=False))
+
+
+def main(argv: list[str] | None = None) -> int:
+    sys.stdout.reconfigure(encoding="utf-8")
+    p = argparse.ArgumentParser(prog="conversor3mf", description="Converte 3MF da Bambu para a Kobra X na ordem do seu ACE.")
+    sub = p.add_subparsers(dest="comando", required=True)
+
+    s = sub.add_parser("inspecionar", help="mostra filamentos, cores e onde cada um é usado")
+    s.add_argument("arquivo")
+
+    s = sub.add_parser("planejar", help="mostra em qual slot cada cor vai sair, sem gravar nada")
+    s.add_argument("arquivo")
+    s.add_argument("--mapa", help="força slots, ex.: 1=3,2=1 (filamento do modelo = slot do ACE)")
+
+    s = sub.add_parser("converter", help="grava o 3MF convertido")
+    s.add_argument("arquivo")
+    s.add_argument("--mapa", help="força slots, ex.: 1=3,2=1")
+    s.add_argument("--saida", help="caminho do arquivo convertido (padrão: <nome>_KobraX.3mf)")
+    s.add_argument("--sem-verificar", action="store_true", help="não confere no slicer depois de gravar")
+
+    s = sub.add_parser("verificar", help="abre o arquivo no Anycubic Slicer Next e confere")
+    s.add_argument("arquivo")
+
+    s = sub.add_parser("ilhas", help="desenha o objeto com o número de cada região de mesma cor")
+    s.add_argument("arquivo")
+    s.add_argument("--vista", default="cima", choices=["cima", "baixo", "frente", "tras", "esquerda", "direita"])
+    s.add_argument("--objeto")
+    s.add_argument("--regiao", help="zoom em mm: x0,y0,x1,y1")
+    s.add_argument("--png", help="onde salvar a imagem (padrão: <nome>_ilhas_<vista>.png ao lado)")
+
+    s = sub.add_parser("repintar", help="grava um 3MF novo com ilhas em outro slot")
+    s.add_argument("arquivo")
+    s.add_argument("mudancas", help="ilha=slot separados por vírgula, ex.: 32=4,3=3")
+    s.add_argument("--objeto")
+    s.add_argument("--saida")
+
+    s = sub.add_parser("ace", help="mostra ou altera os slots do ACE")
+    acoes = s.add_subparsers(dest="acao", required=True)
+    acoes.add_parser("mostrar")
+    d = acoes.add_parser("definir", help="usa um projeto salvo no slicer (com o ACE sincronizado) como molde")
+    d.add_argument("projeto")
+    t = acoes.add_parser("slot", help="troca cor/tipo/nome de um slot")
+    t.add_argument("numero", type=int)
+    t.add_argument("--cor")
+    t.add_argument("--tipo")
+    t.add_argument("--nome")
+
+    a = p.parse_args(argv)
+    if a.comando == "inspecionar":
+        _mostrar(ler_projeto(a.arquivo).resumo())
+    elif a.comando == "planejar":
+        _mostrar(planejar(ler_projeto(a.arquivo), modulo_ace.carregar(), _mapa(a.mapa)).resumo())
+    elif a.comando == "converter":
+        resultado = converter(a.arquivo, a.saida, _mapa(a.mapa))
+        dados = resultado.resumo()
+        if not a.sem_verificar:
+            dados["verificacao"] = verificar(resultado.destino)
+        _mostrar(dados)
+    elif a.comando == "verificar":
+        _mostrar(verificar(a.arquivo))
+    elif a.comando == "ilhas":
+        regiao = [float(x) for x in a.regiao.split(",")] if a.regiao else None
+        png, info = ilhas.mapa_de_ilhas(a.arquivo, a.objeto, a.vista, regiao)
+        destino = Path(a.png) if a.png else Path(a.arquivo).with_name(f"{Path(a.arquivo).stem}_ilhas_{a.vista}.png")
+        destino.write_bytes(png)
+        _mostrar({"imagem": str(destino), **info})
+    elif a.comando == "repintar":
+        resultado = ilhas.repintar_ilhas(a.arquivo, _mapa(a.mudancas), a.objeto, a.saida)
+        resultado["verificacao"] = verificar(resultado["arquivo_repintado"])
+        _mostrar(resultado)
+    elif a.comando == "ace":
+        if a.acao == "mostrar":
+            _mostrar(modulo_ace.carregar().resumo())
+        elif a.acao == "definir":
+            _mostrar(modulo_ace.definir_molde(a.projeto).resumo())
+        else:
+            _mostrar(modulo_ace.alterar_slot(a.numero, a.cor, a.tipo, a.nome).resumo())
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

conversor3mf/ace.py

@@ -0,0 +1,203 @@
+"""Molde de configuração da impressora e slots do ACE.
+
+O molde é tirado de um projeto salvo pelo próprio Anycubic Slicer Next depois de
+sincronizar o ACE: ele já traz impressora, perfis de filamento e a ordem real
+dos carretéis. O arquivo `dados/meu_ace.json` guarda os slots e pode ser
+editado à mão (por exemplo, para trocar a cor de um slot sem salvar outro molde).
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import zipfile
+from dataclasses import asdict, dataclass
+from pathlib import Path
+
+from . import cores
+from .config import pasta_dados, pasta_perfis
+
+__all__ = ["Slot", "Ace", "definir_molde", "carregar", "alterar_slot", "aplicar_slots"]
+
+ARQUIVO_ACE = "meu_ace.json"
+ARQUIVO_MOLDE = "molde_project_settings.json"
+
+# Espaçamento entre placas medido em projetos salvos pelo Anycubic Slicer Next
+ESPACAMENTO_PLACAS = {"Anycubic Kobra X": (314.4, 328.8)}
+
+
+@dataclass
+class Slot:
+    slot: int
+    cor: str
+    tipo: str
+    nome: str
+    perfil: str
+
+
+@dataclass
+class Ace:
+    slots: list[Slot]
+    molde: dict
+    origem: str
+
+    @property
+    def impressora(self) -> str:
+        return self.molde.get("printer_model", "?")
+
+    def resumo(self) -> dict:
+        return {
+            "impressora": self.impressora,
+            "molde_tirado_de": self.origem,
+            "slots": [asdict(s) for s in self.slots],
+        }
+
+
+def _chaves_de_filamento() -> set[str]:
+    """Todas as chaves que aparecem em perfis de filamento do slicer."""
+    chaves = {"filament_colour", "filament_colour_info", "filament_settings_id", "default_filament_colour"}
+    perfis = pasta_perfis()
+    for arquivo in (perfis / "filament").glob("*.json") if perfis else []:
+        try:
+            chaves |= set(json.loads(arquivo.read_text(encoding="utf8")))
+        except (OSError, ValueError):
+            continue
+    return chaves - {"name", "inherits", "from", "type", "setting_id", "instantiation", "version",
+                     "compatible_printers", "compatible_printers_condition", "is_custom_defined",
+                     "filament_id"}
+
+
+def perfil_de_processo(nome: str) -> dict | None:
+    perfis = pasta_perfis()
+    caminho = perfis / "process" / f"{nome}.json" if perfis else None
+    if caminho is None or not caminho.exists():
+        return None
+    perfil = json.loads(caminho.read_text(encoding="utf8"))
+    if perfil.get("inherits"):
+        base = perfil_de_processo(perfil["inherits"]) or {}
+        perfil = {**base, **perfil}
+    return perfil
+
+
+CHAVES_META = {"type", "from", "setting_id", "is_custom_defined", "instantiation", "version",
+               "inherits", "name", "compatible_printers", "compatible_printers_condition"}
+
+
+def definir_molde(projeto_3mf: str | Path) -> Ace:
+    """Lê um projeto salvo pelo Anycubic Slicer Next e grava molde + slots em dados/."""
+    projeto_3mf = Path(projeto_3mf)
+    with zipfile.ZipFile(projeto_3mf) as arquivo:
+        config = json.loads(arquivo.read("Metadata/project_settings.config"))
+        principal = arquivo.read("3D/3dmodel.model").decode("utf8")
+        embutidos = [n for n in arquivo.namelist()
+                     if re.match(r"Metadata/(machine|filament|process)_settings_\d+\.config$", n)]
+    if not str(config.get("printer_model", "")).startswith("Anycubic"):
+        raise ValueError(f"o projeto é de {config.get('printer_model')}, preciso de um salvo para a impressora Anycubic")
+    diferencas = config.get("different_settings_to_system") or []
+    if diferencas and diferencas[-1]:
+        raise ValueError(
+            "o perfil de impressora desse projeto foi modificado "
+            f"({diferencas[-1][:120]}). Salve um projeto usando o perfil de sistema da impressora."
+        )
+    if any("machine_settings" in n for n in embutidos):
+        # projetos com perfil de impressora embutido podem carregar G-code de outra máquina
+        raise ValueError("o projeto traz um perfil de impressora personalizado embutido; use outro projeto")
+
+    # processo volta ao perfil de fábrica; as escolhas do modelo entram na conversão
+    perfil = perfil_de_processo(config.get("print_settings_id", ""))
+    if perfil:
+        for chave, valor in perfil.items():
+            if chave not in CHAVES_META and chave in config:
+                config[chave] = valor
+        if diferencas:
+            diferencas[0] = ""
+    app = re.search(r'<metadata name="Application">([^<]*)<', principal)
+    config["_aplicativo"] = app.group(1) if app else f"BambuStudio-{config.get('version', '2.0.0.3')}"
+
+    n = len(config.get("filament_colour") or [])
+    slots = [
+        Slot(
+            slot=i + 1,
+            cor=cores.normalizar(config["filament_colour"][i]),
+            tipo=config["filament_type"][i],
+            nome=cores.nome_da_cor(config["filament_colour"][i]),
+            perfil=config["filament_settings_id"][i],
+        )
+        for i in range(n)
+    ]
+    pasta_dados().mkdir(parents=True, exist_ok=True)
+    (pasta_dados() / ARQUIVO_MOLDE).write_text(json.dumps(config, indent=1, ensure_ascii=False), encoding="utf8")
+    ace = Ace(slots=slots, molde=config, origem=str(projeto_3mf))
+    salvar_slots(ace)
+    return ace
+
+
+def salvar_slots(ace: Ace) -> None:
+    dados = {
+        "_leia_me": "Slots do ACE na ordem da impressora. Pode editar cor e nome; "
+        "para mudar o tipo use um tipo que já exista em algum slot do molde.",
+        "molde_tirado_de": ace.origem,
+        "slots": [asdict(s) for s in ace.slots],
+    }
+    pasta_dados().mkdir(parents=True, exist_ok=True)
+    (pasta_dados() / ARQUIVO_ACE).write_text(json.dumps(dados, indent=2, ensure_ascii=False), encoding="utf8")
+
+
+def carregar() -> Ace:
+    caminho_molde = pasta_dados() / ARQUIVO_MOLDE
+    caminho_ace = pasta_dados() / ARQUIVO_ACE
+    if not caminho_molde.exists() or not caminho_ace.exists():
+        raise FileNotFoundError(
+            "ainda não há molde do ACE. Salve um projeto no Anycubic Slicer Next com o ACE "
+            "sincronizado e rode: python -m conversor3mf ace definir <projeto.3mf>"
+        )
+    molde = json.loads(caminho_molde.read_text(encoding="utf8"))
+    dados = json.loads(caminho_ace.read_text(encoding="utf8"))
+    slots = [Slot(**{**s, "cor": cores.normalizar(s["cor"])}) for s in dados["slots"]]
+    tipos_no_molde = set(molde.get("filament_type") or [])
+    for s in slots:
+        if s.tipo not in tipos_no_molde:
+            raise ValueError(
+                f"slot {s.slot} está como {s.tipo}, mas o molde só tem {sorted(tipos_no_molde)}. "
+                "Salve um projeto no slicer com esse filamento e defina o molde de novo."
+            )
+    return Ace(slots=slots, molde=molde, origem=dados.get("molde_tirado_de", "?"))
+
+
+def alterar_slot(numero: int, cor: str | None = None, tipo: str | None = None, nome: str | None = None) -> Ace:
+    """Atualiza um slot depois de trocar o carretel; o tipo precisa existir no molde."""
+    ace = carregar()
+    slot = next((s for s in ace.slots if s.slot == numero), None)
+    if slot is None:
+        raise ValueError(f"slot {numero} não existe")
+    if tipo:
+        tipos = sorted(set(ace.molde.get("filament_type") or []))
+        if tipo not in tipos:
+            raise ValueError(
+                f"o molde só tem {tipos}. Para usar {tipo}, salve um projeto no slicer com esse "
+                "filamento em algum slot e defina o molde de novo."
+            )
+        slot.tipo = tipo
+    if cor:
+        slot.cor = cores.normalizar(cor)
+        slot.nome = cores.nome_da_cor(slot.cor)
+    if nome:
+        slot.nome = nome
+    salvar_slots(ace)
+    return ace
+
+
+def aplicar_slots(config: dict, ace: Ace) -> None:
+    """Ajusta as listas por filamento do config para refletir os slots (cor e tipo)."""
+    chaves = _chaves_de_filamento()
+    n = len(ace.slots)
+    tipos_molde = list(config.get("filament_type") or [])
+    original = {k: list(v) for k, v in config.items() if k in chaves and isinstance(v, list) and len(v) == n}
+    for i, slot in enumerate(ace.slots):
+        if i < len(tipos_molde) and tipos_molde[i] != slot.tipo:
+            fonte = tipos_molde.index(slot.tipo)
+            for chave, valores in original.items():
+                config[chave][i] = valores[fonte]
+        config["filament_colour"][i] = slot.cor
+        if "filament_colour_info" in config and i < len(config["filament_colour_info"]):
+            config["filament_colour_info"][i] = slot.cor

conversor3mf/config.py

@@ -0,0 +1,106 @@
+"""Onde ficam os dados do usuário e o Anycubic Slicer Next.
+
+Variáveis de ambiente (opcionais):
+- CONVERSOR3MF_DADOS: pasta do molde e dos slots do ACE
+- CONVERSOR3MF_SLICER: pasta de instalação do Anycubic Slicer Next (ou o executável)
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+__all__ = ["pasta_dados", "pasta_slicer", "executavel_slicer", "pasta_perfis"]
+
+NOME_APP = "conversor3mf"
+
+
+def pasta_dados() -> Path:
+    if os.environ.get("CONVERSOR3MF_DADOS"):
+        return Path(os.environ["CONVERSOR3MF_DADOS"])
+    if sys.platform == "win32":
+        return Path(os.environ.get("APPDATA", Path.home() / "AppData" / "Roaming")) / NOME_APP
+    if sys.platform == "darwin":
+        return Path.home() / "Library" / "Application Support" / NOME_APP
+    return Path(os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config")) / NOME_APP
+
+
+def _do_registro() -> list[Path]:
+    if sys.platform != "win32":
+        return []
+    import winreg
+
+    achados = []
+    chaves = [
+        (winreg.HKEY_LOCAL_MACHINE, r"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall"),
+        (winreg.HKEY_LOCAL_MACHINE, r"SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall"),
+        (winreg.HKEY_CURRENT_USER, r"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall"),
+    ]
+    for raiz, caminho in chaves:
+        try:
+            pai = winreg.OpenKey(raiz, caminho)
+        except OSError:
+            continue
+        with pai:
+            for i in range(winreg.QueryInfoKey(pai)[0]):
+                try:
+                    with winreg.OpenKey(pai, winreg.EnumKey(pai, i)) as filho:
+                        nome = str(winreg.QueryValueEx(filho, "DisplayName")[0])
+                        if "anycubicslicernext" not in nome.replace(" ", "").lower():
+                            continue
+                        for valor in ("DisplayIcon", "UninstallString", "InstallLocation"):
+                            try:
+                                texto = str(winreg.QueryValueEx(filho, valor)[0]).strip('" ').split(",")[0]
+                            except OSError:
+                                continue
+                            if texto:
+                                p = Path(texto)
+                                achados.append(p.parent if p.suffix.lower() == ".exe" else p)
+                except OSError:
+                    continue
+    return achados
+
+
+def pasta_slicer() -> Path | None:
+    """Pasta de instalação do Anycubic Slicer Next, ou None se não encontrar."""
+    candidatos: list[Path] = []
+    escolhido = os.environ.get("CONVERSOR3MF_SLICER")
+    if escolhido is not None and escolhido.strip().lower() in ("", "nenhum", "none"):
+        return None  # usado nos testes: finge que o slicer não está instalado
+    if escolhido:
+        p = Path(escolhido)
+        candidatos.append(p.parent if p.is_file() else p)
+    candidatos += _do_registro()
+    if sys.platform == "win32":
+        for base in (os.environ.get("ProgramFiles"), os.environ.get("ProgramFiles(x86)"), os.environ.get("LOCALAPPDATA")):
+            if base:
+                candidatos += [Path(base) / "AnycubicSlicerNext", Path(base) / "Programs" / "AnycubicSlicerNext"]
+    elif sys.platform == "darwin":
+        candidatos.append(Path("/Applications/AnycubicSlicerNext.app"))
+    for c in candidatos:
+        if executavel_slicer(c) is not None:
+            return c
+    return None
+
+
+def executavel_slicer(pasta: Path | None = None) -> Path | None:
+    pasta = pasta if pasta is not None else pasta_slicer()
+    if pasta is None:
+        return None
+    for p in (pasta / "AnycubicSlicerNext.exe", pasta / "Contents" / "MacOS" / "AnycubicSlicerNext"):
+        if p.is_file():
+            return p
+    return None
+
+
+def pasta_perfis() -> Path | None:
+    """Pasta com os perfis de sistema da Anycubic (processo, filamento, impressora)."""
+    pasta = pasta_slicer()
+    if pasta is None:
+        return None
+    for p in (pasta / "resources" / "profiles" / "Anycubic",
+              pasta / "Contents" / "Resources" / "profiles" / "Anycubic"):
+        if p.is_dir():
+            return p
+    return None