Exporter DRC UI

exporter/SynthesisFusionAddin/src/UI/ConfigCommand.py

@@ -15,12 +15,14 @@
 
 import src.Parser.ExporterOptions as moduleExporterOptions
 import src.Parser.SynthesisParser.Parser as Parser
+import src.UI.DesignCheckTab as DesignCheckTab
 import src.UI.GamepieceConfigTab as GamepieceConfigTab
 import src.UI.GeneralConfigTab as GeneralConfigTab
 import src.UI.JointConfigTab as JointConfigTab
 import src.UI.TaggingConfigTab as TaggingConfigTab
 from src import APP_WEBSITE_URL, Logging, gm
 from src.APS.APS import getAuth, getUserInfo
+from src.lib.DesignRuleChecks import DesignRuleChecks
 from src.lib.Handlers import PersistentEventHandler
 from src.lib.Util import convertMassUnitsTo, designMassCalculation
 from src.Logging import getLogger, logFailure
@@ -32,6 +34,7 @@
 generalConfigTab: GeneralConfigTab.GeneralConfigTab
 jointConfigTab: JointConfigTab.JointConfigTab
 gamepieceConfigTab: GamepieceConfigTab.GamepieceConfigTab
+designCheckTab: DesignCheckTab.DesignCheckTab
 taggingConfigTab: TaggingConfigTab.TaggingConfigTab
 
 exporterPalette: Palette
@@ -50,6 +53,7 @@ def reload() -> None:
     importlib.reload(GeneralConfigTab)
     importlib.reload(GamepieceConfigTab)
     importlib.reload(JointConfigTab)
+    importlib.reload(DesignCheckTab)
     importlib.reload(TaggingConfigTab)
 
     importlib.reload(moduleExporterOptions)
@@ -113,6 +117,10 @@ def notify(self, args: adsk.core.CommandCreatedEventArgs) -> None:
             taggingConfigTab = TaggingConfigTab.TaggingConfigTab(args)
             generalConfigTab.taggingConfigTab = taggingConfigTab
 
+            global designCheckTab
+            designCheckTab = DesignCheckTab.DesignCheckTab(args)
+            generalConfigTab.designCheckTab = designCheckTab
+
             if not exporterOptions.exportMode == ExportMode.FIELD:
                 gamepieceConfigTab.isVisible = False
 
@@ -292,6 +300,9 @@ def notify(self, html_args: adsk.core.HTMLEventArgs) -> None:
         elif html_args.action == "cancelSelection":
             gm.ui.terminateActiveCommand()
             html_args.returnData = "{}"
+
+        elif html_args.action == "designRules":
+            html_args.returnData = json.dumps(DesignRuleChecks().getDesignRules())
         else:
             gm.ui.messageBox(f"Event {html_args.action} arrived<span>{json.dumps(data, indent=2)}</span>")
 

exporter/SynthesisFusionAddin/src/UI/DesignCheckTab.py

@@ -0,0 +1,62 @@
+from typing import Any, Callable, Dict, List, TypedDict, cast
+
+import adsk.core
+import adsk.fusion
+
+from src import Logging
+from src.lib import IconPaths
+from src.lib.DesignRuleChecks import DesignRuleChecks
+
+logger = Logging.getLogger()
+
+
+class DesignCheckTab:
+    designCheckTab: adsk.core.TabCommandInput
+    designCheckTable: adsk.core.TableCommandInput
+
+    @Logging.logFailure
+    def __init__(self, args: adsk.core.CommandCreatedEventArgs) -> None:
+        self.designCheckTab = args.command.commandInputs.addTabCommandInput("designCheckTab", "Design Rule Check")
+        designCheckTabInputs = self.designCheckTab.children
+
+        # Create the table for design checks
+        self.designCheckTable = designCheckTabInputs.addTableCommandInput(
+            "designCheckTable", "Design Checks", 3, "3:2:2"
+        )
+        self.designCheckTable.tablePresentationStyle = (
+            adsk.core.TablePresentationStyles.itemBorderTablePresentationStyle
+        )
+
+        for i, rule in enumerate(DesignRuleChecks().getDesignRules()):
+            calculation = rule["calculation"]
+            max_value: float = rule["max_value"]
+            value: float = calculation()
+            is_valid: bool = value <= max_value
+            rule_name: str = str(rule["name"])
+            rule_id: str = rule_name.replace(" ", "")
+
+            name_input = designCheckTabInputs.addTextBoxCommandInput(f"{rule_id}Name", rule_name, rule_name, 1, True)
+            value_input = designCheckTabInputs.addTextBoxCommandInput(
+                f"{rule_id}Value", "Value", f"{value:.2f} cm", 1, True
+            )
+            icon_input = designCheckTabInputs.addImageCommandInput(
+                f"{rule_id}StatusIcon",
+                "",
+                IconPaths.designCheckIcons["valid"] if is_valid else IconPaths.designCheckIcons["invalid"],
+            )
+
+            self.designCheckTable.addCommandInput(name_input, i, 0)
+            self.designCheckTable.addCommandInput(value_input, i, 1)
+            self.designCheckTable.addCommandInput(icon_input, i, 2)
+
+    @property
+    def isVisible(self) -> bool:
+        return self.designCheckTab.isVisible or False
+
+    @isVisible.setter
+    def isVisible(self, value: bool) -> None:
+        self.designCheckTab.isVisible = value
+
+    @property
+    def isActive(self) -> bool:
+        return self.designCheckTab.isActive or False

exporter/SynthesisFusionAddin/src/UI/GeneralConfigTab.py

@@ -11,6 +11,7 @@
 from src.Parser.ExporterOptions import ExporterOptions
 from src.Types import KG, ExportLocation, ExportMode, UnitSystem
 from src.UI.CreateCommandInputsHelper import createBooleanInput
+from src.UI.DesignCheckTab import DesignCheckTab
 from src.UI.GamepieceConfigTab import GamepieceConfigTab
 from src.UI.JointConfigTab import JointConfigTab
 from src.UI.TaggingConfigTab import TaggingConfigTab
@@ -24,6 +25,7 @@ class GeneralConfigTab:
     previousSelectedModeDropdownIndex: int
     jointConfigTab: JointConfigTab
     gamepieceConfigTab: GamepieceConfigTab
+    designCheckTab: DesignCheckTab
     taggingConfigTab: TaggingConfigTab
 
     @logFailure

exporter/SynthesisFusionAddin/src/lib/DesignRuleChecks.py

@@ -0,0 +1,50 @@
+from typing import Callable, List, TypedDict
+
+import adsk.core
+import adsk.fusion
+
+from src import Logging, gm
+
+
+class DesignRule(TypedDict):
+    name: str
+    calculation: Callable[[], float]
+    max_value: float
+
+
+class DesignRuleChecks:
+    designRules: List[DesignRule]
+
+    @Logging.logFailure
+    def __init__(self) -> None:
+        self.designRules = [
+            {
+                "name": "Design Height",
+                "calculation": self.fusion_design_height(),
+                "max_value": 106.0,  # cm
+            },
+            {
+                "name": "Design Perimeter",
+                "calculation": self.fusion_design_perimeter(),
+                "max_value": 304.0,  # cm
+            },
+        ]
+
+    def getDesignRules(self) -> List[DesignRule]:
+        return self.designRules
+
+    @Logging.logFailure
+    def fusion_design_height(self) -> float:
+        design = adsk.fusion.Design.cast(gm.app.activeProduct)
+        if design:
+            overall_bounding_box = design.rootComponent.orientedMinimumBoundingBox
+            return float(overall_bounding_box.width)
+        return 0.0
+
+    @Logging.logFailure
+    def fusion_design_perimeter(self) -> float:
+        design = adsk.fusion.Design.cast(gm.app.activeProduct)
+        if design:
+            overall_bounding_box = design.rootComponent.orientedMinimumBoundingBox
+            return float(2 * (overall_bounding_box.height + overall_bounding_box.length))
+        return 0.0

exporter/SynthesisFusionAddin/src/lib/IconPaths.py

@@ -43,6 +43,11 @@
     "friction_override-enabled": resources + os.path.join("FrictionOverride_icon"),  # resource folder
 }
 
+designCheckIcons = {
+    "valid": resources + os.path.join("DesignCheckIcons", "valid-preview93x18.png"),
+    "invalid": resources + os.path.join("DesignCheckIcons", "invalid-preview112x18.png"),
+}
+
 tagIcons = {
     "blank": resources + "blank-preview16x16.png",
 }

exporter/SynthesisFusionAddin/web/src/App.tsx

@@ -1,7 +1,7 @@
 import { useCallback, useEffect, useState } from "react"
 
 import "./App.css"
-import { RestartAlt, Settings, SportsFootball, Texture } from "@mui/icons-material"
+import { CheckBox, RestartAlt, Settings, SportsFootball, Texture } from "@mui/icons-material"
 import DownloadIcon from "@mui/icons-material/Download"
 import PrecisionManufacturingIcon from "@mui/icons-material/PrecisionManufacturing"
 import SaveIcon from "@mui/icons-material/Save"
@@ -32,6 +32,7 @@ import {
     type Joint,
     WheelType,
 } from "./lib/types.ts"
+import DesignCheckTab from "./ui/DesignCheckTab.tsx"
 import GamepiecesConfigTab from "./ui/GamepiecesConfigTab.tsx"
 import GeneralConfigTab from "./ui/GeneralConfigTab.tsx"
 import GlobalAlert from "./ui/GlobalAlert.tsx"
@@ -228,6 +229,7 @@ function App() {
                         />
 
                         <Tab icon={<Texture />} iconPosition={"start"} label="Materials" />
+                        <Tab icon={<CheckBox />} iconPosition={"start"} label="Design Check" />
 
                         {/*<Tab label="APS" />*/}
                     </Tabs>
@@ -259,6 +261,9 @@ function App() {
                     selection={{ isSelecting, setIsSelecting }}
                 />
             </TabPanel>
+            <TabPanel value={activeTab} index={4}>
+                <DesignCheckTab />
+            </TabPanel>
             <Container
                 sx={{
                     position: "sticky",

exporter/SynthesisFusionAddin/web/src/lib/index.ts

@@ -28,6 +28,7 @@ interface Messages {
     selectJoint: [Empty, FusionJoint]
     selectGamepiece: [Empty, FusionGamepiece[]]
     selectBody: [Empty, FusionBody]
+    designRules: [Empty, DesignRule[]]
     export: [ExporterConfig, Empty]
     save: [ExporterConfig, Empty]
     init: [Empty, InitResponse]
@@ -146,3 +147,23 @@ window.fusionJavaScriptHandler = {
         return "OK"
     },
 }
+
+export interface DesignRule {
+    name: string
+    calculation: number
+    max_value: number
+}
+export async function getDesignRules(): Promise<DesignRule[] | undefined> {
+    if (import.meta.env.DEV && typeof window.adsk === "undefined") {
+        return new Promise<DesignRule[]>(resolve => {
+            setTimeout(() => {
+                resolve([
+                    { name: "Rule 1", calculation: 10, max_value: 20 },
+                    { name: "Rule 2", calculation: 25, max_value: 20 },
+                    { name: "Rule 3", calculation: 5, max_value: 15 },
+                ])
+            }, 1000)
+        })
+    }
+    return await sendData("designRules", {})
+}

exporter/SynthesisFusionAddin/web/src/ui/DesignCheckTab.tsx

@@ -0,0 +1,66 @@
+import { Paper, Table, TableBody, TableCell, TableContainer, TableHead, TableRow } from "@mui/material"
+import { useEffect, useState } from "react"
+import { type DesignRule, getDesignRules } from "../lib"
+
+function DesignCheckTab() {
+    const [rules, setRules] = useState<DesignRule[]>([])
+
+    useEffect(() => {
+        const fetchRules = async () => {
+            const data = await getDesignRules()
+            if (data) {
+                setRules(data)
+            }
+        }
+
+        fetchRules()
+    }, [])
+
+    function isDesignValid(): string {
+        rules.forEach(rule => {
+            if (rule.calculation > rule.max_value) {
+                return "Invalid"
+            }
+        })
+
+        return "Valid"
+    }
+
+    return (
+        <>
+            <h4>Checks Passing: {isDesignValid()}</h4>
+            <TableContainer component={Paper} elevation={6}>
+                <Table sx={{ minWidth: 650 }} aria-label="simple table" size={"small"}>
+                    <TableHead>
+                        <TableRow>
+                            <TableCell sx={{ width: "28%" }} align="center">
+                                Component
+                            </TableCell>
+                            <TableCell sx={{ width: "28%" }} align="center">
+                                Calculation
+                            </TableCell>
+                            <TableCell sx={{ width: "40%" }} align="center">
+                                Is Valid
+                            </TableCell>
+                            <TableCell sx={{ width: "4%" }}></TableCell>
+                        </TableRow>
+                    </TableHead>
+                    <TableBody>
+                        {rules.map(rule => (
+                            <TableRow key={rule.name} sx={{ "&:last-child td, &:last-child th": { border: 0 } }}>
+                                <TableCell align="center">{rule.name}</TableCell>
+                                <TableCell align="center">{rule.calculation}</TableCell>
+                                <TableCell align="center">
+                                    {rule.calculation <= rule.max_value ? "Valid" : "Invalid"}
+                                </TableCell>
+                                <TableCell />
+                            </TableRow>
+                        ))}
+                    </TableBody>
+                </Table>
+            </TableContainer>
+        </>
+    )
+}
+
+export default DesignCheckTab