ArchGeo Library

Basic Library	Related Projects	License	Documentation
Numpy,SciPy,Mayavi,geometrylab	Discrete Orthogonal Structures

ArchGeo is a geometry processing library with integrated visualization and optimization capabilities, designed to support efficient design and construction by leveraging Discrete Differential Geometry (DDG).

Written in Python, it uses a half-edge data structure to handle various meshes. It also offers visualization and rendering of geometric objects such as point clouds and curves, alongside mesh optimization design. For visualization, it utilizes the Python-based Mayavi3D library, and for optimization, it focuses on quadrilateral meshes using a Guided Projection algorithm and an efficient solver.

Comprehensive documentation for ArchGeo is available, covering core aspects like installation and optimization algorithms. Welcome to check!

This GitHub repository, dedicated to the "Discrete Orthogonal Structures" project, showcases orthogonal quad mesh optimization within the DDG research area. It highlights the capabilities of ArchGeo. More features will be open-sourced soon.

Discrete Orthogonal Structures

Felix Dellinger, Xinye Li, and Hui Wang* (corresponding author)
| Project Page | Full Paper | Publication Page | Documentation |

Abstract

To represent smooth geometric shapes by coarse polygonal meshes, visible edges often follow special families of curves on a surface to achieve visually pleasing results. Important examples of such families are principal curvature lines, asymptotic lines or geodesics. In a surprisingly big amount of use-cases, these curves form an orthogonal net. While the condition of orthogonality between smooth curves on a surface is straightforward, the discrete counterpart, namely orthogonal quad meshes, is not. In this paper, we study the definition of discrete orthogonality based on equal diagonal lengths in every quadrilateral. We embed this definition in the theory of discrete differential geometry and highlight its benefits for practical applications. We demonstrate the versatility of this approach by combining discrete orthogonality with other classical constraints known from discrete differential geometry. Orthogonal multi-nets, i.e. meshes where discrete orthogonality holds on any parameter rectangle, receive an in-depth analysis.

This repository contains the implementation associated with the paper "Discrete Orthogonal Structures". Please cite the paper if you use this code in your project.

BibTeX

@Article{DOS2023,
      author       = {Dellinger, Felix and Li, Xinye and Wang, Hui},
      title        = {Discrete Orthogonal Structures},
      journal      = {Computers & Graphics},
      volume       = {114},
      pages        = {126--137},
      month        = {June},
      year         = {2023},
      doi          = {10.1016/j.cag.2023.05.024},
      url          = {https://www.huiwang.me/projects/10_project/}
}

Set up a working environment in Windows / MacOS

Using Anaconda to install every package.

1. Download Anaconda

2. Open Anaconda Prompt
```
$ conda create -n geo 
$ conda activate geo
$ conda install mayavi traits traitsui qt pyqt vtk scipy spyder 
$ conda install -c haasad pypardiso
```
3. Open Anaconda, under "geo" environment open Spyder

Once above installation failed because of versions conflict, then try below installations:

step-by-step installation.

```
$ conda create -n geo python=3.6
$ conda activate geo
$ pip install numpy scipy
$ pip install python-vtk
$ pip install mayavi --no-cache
$ conda install -c haasad pypardiso
$ conda install pyface
```

Or use the exported files within ./conda/ to set your environment

```
$ conda env create -f environment.yml
```

File Relations

File tree.

File notice.

• files in geometrylab folder are basic, nothing need to be changed.

• archgeolab/archgeometry: meshpy.py --> quadrings.py --> gridshell_new.py --> gui_basic.py --> guidedprojection_orthonet.py --> opt_gui_orthonet.py --> readfile_orthonet.py

• run readfile_orthonet.py to test how it works; a GUI window will be opened

• The GUI settings are in opt_gui_orthonet.py

• The constraints settings are in guidedprojection_orthonet.py

• if you want to add a new optimization project, please refer to archgeolab; You can create a new folder similar to the folder 'archgeolab'. Then the mesh geometry, optimization and GUI will be based on the files in geometrylab folder.

Mesh Optimization

It utilizes the Guided Projection Algorithm, a Gauss-Newton algorithm, as discussed in the paper Form-finding with polyhedral meshes made simple, to optimize and generate quadmesh models.

Abstract of the paper 'Form-finding with Polyhedral Meshes Made Simple'

We solve the form-finding problem for polyhedral meshes in a way which combines form, function and fabrication; taking care of user-specified constraints like boundary interpolation, planarity of faces, statics, panel size and shape, enclosed volume, and last, but not least, cost. Our main application is the interactive modeling of meshes for architectural and industrial design. Our approach can be described as guided exploration of the constraint space whose algebraic structure is simplified by introducing auxiliary variables and ensuring that constraints are at most quadratic. Computationally, we perform a projection onto the constraint space which is biased towards low values of an energy which expresses desirable "soft" properties like fairness. We have created a tool which elegantly handles difficult tasks, such as taking boundary-alignment of polyhedral meshes into account, planarization, fairing under planarity side conditions, handling hybrid meshes, and extending the treatment of static equilibrium to shapes which possess overhanging parts.

ArchGeo Visualization

This implementation primarily addresses optimization problems involving quad meshes, offering a robust tool for researchers and practitioners in Geometry Processing and Architectural Geometry. It is designed to streamline the exploration and resolution of intricate geometric optimization tasks, enhancing the visualization and comprehension of the underlying processes and results.

Implementation layout

Implementation of a principal net optimized from an orthogonal PQ mesh

Implementation of a minimal net optimized from an orthogonal A-net

Implementation of a CMC net optimized from an orthogonal S-net with const. radius

Implementation of a principal stress net from an orthogonal equilibrium mesh

---

Contributions

ArchGeo, initially developed by Davide Pellis, originated from TU Wien's research in architectural geometry and has since evolved through projects at KAUST and Xi'an Jiaotong University. This journey has resulted in around 20 high-quality academic publications. Its core algorithms can be integrated with Rhino3D's Grasshopper plugin, significantly aiding in the design of large-scale grid shells. This integration exemplifies ArchGeo's pivotal role in advancing geometric design and construction.

ArchGeo is a user-friendly, Python-based geometry processing tool with an intuitive GUI for efficient geometric design. It serves as an excellent entry point for research in DDG, CAD, and CG. Looking ahead, ArchGeo aims to expand its industrial software applications, particularly in education and research. It also seeks to deepen its integration with industrial tools like Rhino3D and support geometric optimization across various applications.

If you find our codebase and paper valuable for your research, we encourage you to cite the paper and star ⭐ our GitHub repository. ArchGeo is continuously being developed, and we welcome any issues or contribution requests. We also invite collaboration on developing a Grasshopper plugin. For commercial use, kindly contact us.

We hope this codebase proves useful for your research endeavors.