Merge branch 'main' of https://github.com/greamarchitects/geoTRIC

Author: greamarchitects

README.md

@@ -1,144 +1,169 @@
-# geoTRIC 
-geoTRIC is a modular computational design toolkit developed through a progressive series of geometric systems.
-Each module builds conceptually and technically on the previous one — moving from 2D grammar rules to 3D surface-driven tower systems.
+# geoTRIC
 
-The project explores structure, iteration, transformation, matrices, and attractor-driven geometry within Rhinoceros using Python (RhinoScriptSyntax).
+Procedural computational design toolkit for geometric systems, skeletal structures, spatial matrices, and attractor-driven architectural generation.
+---
+
+# Modules
+
+```text
+01 grammatric  → Shape Grammars
+02 skeletric   → Skeletal Graphs
+03 pattric     → Pattern Fields
+04 mattric     → 3D Matrices
+05 hiritric    → Surface Tower Systems
+```
+
+Each module extends the previous one through:
+* dimensional complexity
+* iteration systems
+* attractor logic
+* vector fields
+* procedural control
 
 ---
 
-## Project Structure
+# Structure
 
+```text
 geoTRIC/
+│
 ├── 01_grammatric/
 ├── 02_skeletric/
 ├── 03_pattric/
 ├── 04_mattric/
-└── 05_hiritric/
-
-Each module represents a conceptual and technical evolution.
+├── 05_hiritric/
+│
+├── api/
+│   ├── core/
+│   ├── rhino/
+│   ├── blender/
+│   ├── freecad/
+│   ├── revit/
+│   └── autocad/
+│
+├── render/
+└── examples/
+```
 
 ---
 
-# 01 — grammatric  
-### Shape Grammars & Transformations (2D)
-
-**Focus:** Rule-based geometric generation.
-
-- Create base shapes (points, lines, curves)
-- Apply transformations (translate, rotate, scale)
-- Define grammar rules (match → replace)
-- Generate sequential derivations
-- Export visual states
-
-**Core Idea:**  
-Geometry as language. Shapes become symbols; transformations become syntax.
+# API Logic
+
+```text
+Core Geometry
+↓
+Abstract Geometry
+↓
+Platform Adapter
+↓
+Rhino / Blender Objects
+↓
+Rendering / GIF Export
+```
+
+## Visual Sequence
+
+```text
+                ┌─────────────────────┐
+                │ grammatric.py       │
+                │ skeleton.py         │
+                │ pattern.py          │
+                │ matrix.py           │
+                │ surface.py          │
+                └──────────┬──────────┘
+                           │
+                           ▼
+                ┌─────────────────────┐
+                │ ABSTRACT GEOMETRY   │
+                │                     │
+                │ Polyline            │
+                │ Column              │
+                │ Matrix              │
+                │ Graph               │
+                └──────────┬──────────┘
+                           │
+        ┌──────────────────┼──────────────────┐
+        ▼                  ▼                  ▼
+┌──────────────┐  ┌──────────────┐  ┌──────────────┐
+│ Rhino API    │  │ Blender API  │  │ Future APIs  │
+│ Adapter      │  │ Adapter      │  │ Revit/FCAD   │
+└──────┬───────┘  └──────┬───────┘  └──────┬───────┘
+       │                 │                 │
+       ▼                 ▼                 ▼
+ Rhino Objects     Blender Objects    BIM Objects
+       │                 │
+       ▼                 ▼
+ Rendering         Rendering
+       │
+       ▼
+ GIF / PNG / MP4
+```
+
+Core geometry is software-independent.
+
+Adapters convert geometry into platform-specific objects.
+
+Current implemented adapters:
+
+* Rhino
+* Blender
 
 ---
 
-# 02 — skeletric  
-### Bone Structures & Sequential States (2D)
+# Current Systems
 
-**Focus:** Skeletal graph systems as control geometry.
+## grammatric
 
-- Generate bone structures (nodes + edges)
-- Sample spines into ordered point lists
-- Derive ribs, branches, and connections
-- Create sequential states through iteration
-- Use attractors and conditionals to control density
+Rule-based shape transformations.
 
-**Core Idea:**  
-Structure precedes form. A skeleton controls complexity.
+## skeletric
 
----
+Node-edge skeletal graph systems.
 
-# 03 — pattric  
-### Pattern Systems & Animation (2D)
+## pattric
 
-**Focus:** Field-based pattern generation driven by skeleton logic.
+Pattern repetition and field variation.
 
-- Use Lists, Dictionaries, Iteration, and Conditionals
-- Populate skeletons with motifs
-- Introduce formal variability across a grid
-- Animate parameters (rotation, scale, density, randomness)
-- Export sequential frames
+## mattric
 
-**Core Idea:**  
-Emergence through repetition and controlled variation.
-
----
+3D matrix and column systems.
 
-# 04 — mattric  
-### 3D Point Matrices & Surface Generation
+## hiritric
 
-**Focus:** Matrix-based spatial systems.
-
-- Generate 3D point matrices (dictionary indexed)
-- Modify matrices via attractor points
-- Loop through matrices to create curves
-- Sweep curves into surfaces and wall systems
-- Produce structured 3D geometries
-
-**Core Idea:**  
-Form emerges from structured spatial fields.
-
----
-
-# 05 — hiritric  
-### Surface Matrices, Normals & Tower Systems
-
-**Focus:** NURBS surfaces and vector-driven geometry.
-
-- Evaluate surface (U,V) parameter space
-- Extract surface normals
-- Modify normals via attractor distance
-- Generate geometry along modified vectors
-- Apply materials and color gradients
-- Produce high-rise tower variations
-
-**Core Idea:**  
-Surface logic becomes architectural system.
+Surface-normal tower generation.
 
 ---
 
-## Conceptual Progression
+# Rendering
 
-grammatric : Shape Grammar
-      ↓
-skeletric : Skeletal Graph
-      ↓
-pattric : Pattern Field
-      ↓
-mattric : 3D Matrix - Surface System
-      ↓
-hiritric : Tower
+```text
+Geometry
+→ Frame Sequence
+→ GIF / MP4
+```
 
-Each module extends the previous one in:
+Used for:
 
-- Dimensional complexity (2D → 3D → surface-driven)
-- Data structure (lists → graphs → dictionaries → matrices)
-- Control logic (rules → iteration → attractors → vector fields)
+* procedural animations
+* geometric studies
+* system visualizations
+* architectural motion graphics
 
 ---
 
-## Technologies
+# Technologies
 
-- Rhinoceros
-- Python
-- RhinoScriptSyntax
-- Lists, Tuples, Dictionaries
-- Iteration & Conditional Execution
-- Attractor Systems
-- Surface Evaluation & Vector Math
+* Python
+* RhinoScriptSyntax
+* RhinoCommon
+* Blender bpy
+* NumPy
 
 ---
 
-## Philosophy
-
-geoTRIC explores the relationship between:
-
-- Structure and variation  
-- Control and emergence  
-- Matrix and surface  
-- Rule and form  
+# Status
 
-It treats geometry as a system rather than a static object.
+Currently focused on:
+* Rhino + Blender workflows
+* API abstraction layer
+* multi-platform procedural geometry