usalu / semio Goto Github PK

✏️Collaborative, scalable and cross-platform designing.

Python 15.76% C# 18.89% Batchfile 0.06% Shell 0.03% Perl 0.79% PowerShell 0.06% JavaScript 0.14% HTML 0.06% SCSS 0.17% TypeScript 64.04%

3d component-based-design design-patterns design-prototypes dynamo generative-design graph-rewriting graph-transformation grasshopper parametric-design

semio's People

Contributors

Stargazers

Watchers

Forkers

fermankamil

semio's Issues

Add python async extension server

SHACL for validating of persistance layer

While it is not necissary to have an ontology to publish and consume rdf, it helps future adopters to have a formal definitions instead of a textual specification.
Additionally it can be used for unittesting with great feedback instead of arbitrary error codes.

Implement (pose) Dependency into element resolving

More general version of current element resolving. Currently all elements are "PointDependent" where they keep their view but change their point of view according the connection.
A more general version can specifiy: Independent (keeps its pose), PointDependent (keeps view but get's point assigned.), ViewDependent (keeps point but get's view assigned.), Dependent (get's pose assigned and doesn't need it's own pose).

Abstract grpc away by adding server and proxy classes in node

Add customization to layout to assemblies with partial assemblies

WYSIWYG vs-code extension as ui for .semio files

As a reference: https://code.visualstudio.com/api/extension-guides/custom-editors

Idea: Reuse Editor code for a layout editor:

Setup workflow to install bazel, buf and poetry (as no native bazel rules)

Develop persistance layer for freezing scripts and easy sharing/reuse

Developing a jupyter like file format (for .semio) to store logic and results (good UI concept necissary).
Something like cells->variants, outputs->designs

Abstract grpc completly away in python package

Finish pipeline for LayoutDesign rpc

Partial architecture looks currently like this:

Use running version to create tests and proceed with Red, Green, Refactor

Migrate connection mechanism buisness logic from semio.py

See https://github.com/usalu/semio.py

Add assemblies to elements logic

Write protoc compiler for grasshopper plugins

Take proto message and create: Goo, Param, Construct and Deconstruct components

Three.js extension (converter + translator)

Setup bazel build tool

As grpc is from google and buf supports bazel, it seems like a good idea to use bazel.

Remove generated code (grpc & protobuf) from source control

Schlenker tool shed example

Add caching functionality

Python adapter

First Grasshopper UI

Migrate unit tests from semio.py

Migrate tests from https://github.com/usalu/semio.py

Sverchok ui

Add layout to assembly logic

Layouts are intended to be a fuzzy description of connected elements in a design. As every element should be placed exactly once, only a tree per connected elements is required. To have potentially the full control, unfinished assemblies can be provided which will be resolved through something like breadth-first search.

Conceptually to achieve this:

An algorithm could be this:

Undirected graphs:

Result would be:

{
    "assemblies": [
        {
            "sobject_id":"1"
        },
        {
            "sobject_id":"3"
        },
        {
            "sobject_id":"6",
            "parts":[
                {
                    "sobject_id":"2"
                }
            ]
        },
        {
            "sobject_id":"10",
            "parts":[
                {
                    "sobject_id":"4",
                    "parts":[
                        {
                            "sobject_id":"5",
                            "parts":[
                                {
                                    "sobject_id":"8"
                                }
                            ]
                        }
                    ]
                },
                {
                    "sobject_id":"9",
                    "parts":[
                        {
                            "sobject_id":"7"
                        },
                        {
                            "sobject_id":"16"
                        }
                    ]
                },
                {
                    "sobject_id":"11"
                }
            ]
        },
        {
            "sobject_id":"14",
            "parts":[
                {
                    "sobject_id":"12"
                },
                {
                    "sobject_id":"17"
                }
            ]
        },
        {
            "sobject_id":"20",
            "parts":[
                {
                    "sobject_id":"19",
                    "parts":[
                        {
                            "sobject_id":"15"
                        },
                        {
                            "sobject_id":"18"
                        }
                    ]
                },
                {
                    "sobject_id":"23"
                }
            ]
        },
        {
            "sobject_id":"21",
            "parts":[
                {
                    "sobject_id":"13"
                },
                {
                    "sobject_id":"22"
                }
            ]
        }
    ]
}

Directed multi graphs;

Idea use networkx as graph engine for finding subcomponents of the graph, do breadth-first search on them, etc