COMPAS Framework

The compas package is the core of the COMPAS framework. It is environment-agnostic and can be used in any Python environment without requiring a CAD system. It provides fundamental functionality for:

• Geometry processing
• Data structures and topology
• Numerical methods
• Robotics
• Plugin mechanisms
• Remote Procedure Calls (RPC)

Core sub-modules include compas.geometry, compas.datastructures, compas.scene, and compas.plugins.

COMPAS is an open-source, Python-based framework designed for computational research and collaboration in architecture, engineering, digital fabrication, and construction (AEFC).

Key architectural components include:

• Core Library: A general-purpose core written in pure Python.
• Extensions: A collection of packages providing access to peer-reviewed research and external libraries (e.g., CGAL, libigl, Triangle).
• Specialized Tools: Integration with industry software like Abaqus, ANSYS, SOFISTIK, and ROS.
• Environment Support: Dedicated packages for Rhino, Grasshopper, and Blender, though it can run in any Python-supported environment.

The compas.data package provides the core infrastructure for data serialization within the COMPAS framework. It is designed to handle the conversion of complex data objects to and from serializable formats (like JSON) while supporting schema validation and structured data management. Key components include:

• Base Data Classes: A foundation for creating data objects.
• JSON Serialization: Custom encoders and decoders for handling COMPAS-specific types.
• Schema Validation: Tools to ensure data integrity using various schema formats.
• Serialization/Deserialization: High-level utilities for dumping and loading data.

The compas_rhino package provides direct integration with Rhino. Use it to:

• Read and write Rhino geometry.
• Visualize COMPAS geometry and data structures in Rhino.
• Perform basic user interaction within the Rhino environment.

Key modules include compas_rhino.conversions, compas_rhino.geometry, and compas_rhino.scene.

The compas_ghpython package allows COMPAS to work within Rhino/Grasshopper via the GHPython component. Use it to:

• Read and write Rhino geometry.
• Visualize COMPAS geometry and data structures inside Grasshopper.

Key modules include compas_ghpython.components and compas_ghpython.scene.

The compas_blender package enables integration between COMPAS and Blender. Use it to:

• Read and write Blender geometry.
• Visualize COMPAS geometry and data structures within the Blender interface.
• Perform basic user interaction within Blender.

Key modules include compas_blender.conversions, compas_blender.geometry, and compas_blender.scene.

The compas.colors package provides classes to work with colors and color maps consistently across different color spaces. It is designed to ensure color consistency in computational geometry and visualization tasks within the COMPAS framework.

Key classes include:

• Color: Represents a single color.
• ColorDict: A dictionary-like structure for managing collections of colors.
• ColorMap: Defines how colors are mapped, typically used for continuous or discrete color scales.

The compas_blender.conversions module provides a suite of functions to bridge the gap between COMPAS data structures and Blender objects. It supports conversions for meshes, curves, surfaces, point clouds, transformations, and materials.

Common conversion directions include:

• COMPAS to Blender: mesh_to_blender, meshobj_to_compas (for specific object types), pointcloud_to_blender, sphere_to_blender_mesh, polyline_to_blender_curve, transformation_to_blender, and color_to_blender_material.
• Blender to COMPAS: bmesh_to_compas, mesh_to_compas, meshobj_to_compas, nurbscurve_to_blender_curve (and related NURBS types), and transformation_to_compas.