Journal Publication de cad-builder sur Maven

Bonjour à tous,

cad-builder a pour objectif de créer un DSL (Domain Specific Language, ou langage ciblé), statiquement typé, pour décrire des pièces en 3D (des corps) et les assemblages de ces pièces en utilisant le moteur CAD d'Opencascade.

Ce projet utilise la JVM avec le langage Groovy pour l’infrastructure du DSL. Le binding avec Opencascade est réalisé par JExtract. Le tout est construit en utilisant Gradle, et est actuellement publié sur Maven (pour Linux x86_64 pour le moment).

Les avantages de cette approche sont de pouvoir :

• gérer les pièces comme un programme :
  • Simplification des opérations de merge ;
  • Cycle de vie plus lisible d'une pièce et de son historique ;
  • Meilleure réutilisation des pièces déjà designées ;
  • Documentation / moteur de recherche
• redistribuer des bibliothèques de pièces, paramétrable, de façon portable, comme des jars pouvant gérer les dépendances ;

Le DSL supporte actuellement :

• Les sélecteurs de face (un peu comme du CSS pour du HTML, c’est sans doute l’aspect le plus important pouvant rendre le langage simple et stable) ;
• Les opérations booléennes fusion, découpage (usinage) et intersection ;
• Les extrusions, rognage, rotation, solidification de chemins clos sur une surface (plane pour le moment).

Les concepts peuvent être mixés.

Un exemple :

@Test
void "Pillow Block With Counterbored Holes and Prism"() {
    cd().box(length, height, thickness).topZ().wireFrom() {
        double rectSX = length - cboreInset
        double rectSY = height - cboreInset
        [[-rectSX / 2, -rectSY / 2], [0, rectSY], [rectSX, 0], [0, -rectSY]].each { double cX, double cY ->
            move(cX, cY)
            circle(centerHoleDia)
        }
    }.toFace().hole(-cboreHoleDiameter).topZ().wireFrom() {
        circle(centerHoleDia)
    }.toFace().prism(cboreHoleDiameter).display()
}

Ce qui donnerait :

Les prochaines évolutions : threading, courbe paramétrique construite sur des surfaces (et non sur des plans seulement), comme dans l’exemple suivant :

static CadDslSolid simpleThreading(CadDslSolid s) {
    cd().thruSection {
        double aMajor = 2 * PI
        double aMinor = myNeckHeight / 10
        Vec2d pos = new Vec2d(2 * PI, myNeckHeight / 2)
        Vec2d dir = new Vec2d(2 * PI, myNeckHeight / 4)

        position(new Vec(myHeight)) {
            direction(new Vec(1))
            cylindricalSurface(myNeckRadius * 0.99)
        }

        wireFromSurface {
            to(pos)
            trimmed(ellipse(dir, aMajor, aMinor), 0, PI)
            to(bound(0))
            edge(bound(PI))
        }
        position(new Vec(myHeight)) {
            direction(new Vec(1))
            cylindricalSurface(myNeckRadius * 1.05)
        }

        wireFromSurface {
            to(pos)
            trimmed(ellipse(dir, aMajor, aMinor), 0, PI)
            to(bound(0))
            edge(bound(PI))
        }
    }
}

Amélioration des prismes pour être plus paramétrable et également étudier l’atelier hélice de la version 8 d’OCCT (Opencascade).

Voilà, ça fait quand même pas mal de travail… mais ce sujet m'intéresse et OCCT commence à me livrer ses secrets.

En revanche, je ne sais pas bien comment gérer les autres architectures : ça fonctionne bien sous mac ARM (hors visualisation), sur Raspberry PI, mais je ne sais pas comment redistribuer le tout via Maven (idem, il faudrait que ça fonctionne sous Windows).

Si certains ou certaines ont une expérience Gradle, de distribution de code natif, ça aiderait !

Merci.