Saravanan666/pypi-org huggingface dataset:
Package: compas-cra
COMPAS CRACoupled Rigid-Block Analysis (CRA)implementation usingCOMPASframework.developed with♥byGene Ting-Chun KaoTo find out more about CRA, please refer to our paper in the CAD Computer-Aided Design journal:https://doi.org/10.1016/j.cad.2022.103216Coupled Rigid-Block Analysis: Stability-Aware Design of Complex Discrete-Element AssembliesAbstractThe rigid-block equilibrium (RBE) method uses a penalty formulation to
measure structural infeasibility or to guide the design of stable
discrete-element assemblies from unstable geometry.
However, RBE is a purely force-based formulation,
and it incorrectly describes stability when
complex interface geometries are involved.
To overcome this issue, this paper introduces
the coupled rigid-block analysis (CRA) method,
a more robust approach building upon RBE’s strengths.
The CRA method combines equilibrium and kinematics in a penalty formulation
in a nonlinear programming problem.
An extensive benchmark campaign is used to show how CRA enables
accurate modelling of complex three-dimensional discrete-element assemblies
formed by rigid blocks.
In addition, an interactive stability-aware design process to
guide user design towards structurally-sound assemblies is proposed.
Finally, the potential of our method for real-world problems are demonstrated
by designing complex and scaffolding-free physical models.Please cite our work if you use CRA in your researchPaper@article{kao2022coupled,
    title     ={Coupled Rigid-Block Analysis: Stability-Aware Design of Complex Discrete-Element Assemblies},
    author    ={Kao, Gene Ting-Chun and Iannuzzo, Antonino and Thomaszewski, Bernhard and Coros, Stelian and Van Mele, Tom and Block, Philippe},
    journal   ={Computer-Aided Design},
    volume    ={146},
    pages     ={103216},
    year      ={2022},
    publisher ={Elsevier},
    doi       ={10.1016/j.cad.2022.103216},
    url       ={https://doi.org/10.1016/j.cad.2022.103216}}Software implementation@misc{compas-cra,
    title  ={{COMPAS CRA}: Coupled Rigid-Block Analysis ({CRA}) for the{COMPAS}framework},
    author ={Gene Ting-Chun Kao},
    note   ={https://github.com/BlockResearchGroup/compas{\_}cra},
    year   ={2020-2022},
    doi    ={10.5281/zenodo.7043135},
    url    ={https://doi.org/10.5281/zenodo.7043135},}Read the docshttps://blockresearchgroup.github.io/compas_craBuild the docs locally$pipinstall-rrequirements-dev.txt
$invokedocs
$opendist/docs/index.html# or open index.html in compas_cra/dist/docs/Examples to reproduce our paper resultsSee examples indocsor try them indocs/examples.
Package: compas-eve
compas_eveCOMPAS Event Extensions: adds event-based communication infrastructure to the COMPAS framework.Getting started with this projectSetup code editorOpen project folder in VS CodeSelect python environment for the projectFirst time using VS Code and on Windows? Make sure select the correct terminal profile:Ctrl+Shift+P,Terminal: Select Default Profileand selectCommand Prompt.All terminal commands in the following sections can be run from the VS Code integrated terminal.First steps with gitGo to theSource controltabMake an initial commit with all newly created filesFirst steps with codeInstall the newly created projectpip install -e .Install it on Rhinopython -m compas_rhino.installCode conventionsCode convention followsPEP8style guidelines and line length of 120 characters.Check adherence to style guidelinesinvoke lintFormat code automaticallyinvoke formatDocumentationDocumentation is generated automatically out of docstrings andRSTfiles in this repositoryGenerate the docsinvoke docsCheck links in docs are validinvoke linkcheckOpen docs in your browser (file explorer ->dist/docs/index.html)TestingTests are written using thepytestframeworkRun all tests from terminalinvoke testOr run them from VS Code from theTestingtabDeveloping Grasshopper componentsWe useGrasshopper Componentizerto develop Python components that can be stored and edited on git.Build componentsinvoke build-ghuser-componentsInstall components on Rhinopython -m compas_rhino.installPublish releaseReleases follow thesemverversioning convention.Create a new releaseinvoke release major
Package: compas-fab
COMPAS FAB: Robotic Fabrication for COMPASRobotic fabrication package for the COMPAS Framework* that facilitates the
planning and execution of robotic fabrication processes. It provides interfaces
to existing software libraries and tools available in the field of robotics
(e.g. OMPL, ROS) and makes them accessible from within the parametric design
environment. The package builds uponCOMPAS,
an open-source Python-based framework for collaboration and research in
architecture, engineering and digital fabrication.Main featuresMultiple backends for simulation and execution (eg.ROS: Robot Operating System)Planning tools: kinematic solvers, path planning, etc.Execution tools: feedback loops, robot control, etc.COMPAS FABruns on Python 3.x and IronPython 2.7.Getting StartedThe recommended way to installCOMPAS FABis to useanaconda/conda:conda install -c conda-forge compas_fabIt can also be installed usingpip:pip install compas_fabOn Windows, you may need to installMicrosoft Visual C++ 14.0.Once the installation is completed, you can verify your setup.
Start Python from the command prompt and run the following:>>> import compas_fabFirst StepsDocumentationCOMPAS FAB ExamplesCOMPAS FAB API ReferenceCOMPAS User GuideCOMPAS API ReferenceQuestions and feedbackWe encourage the use of theCOMPAS framework forumfor questions and discussions.ContributingWe love contributions!Check theContributor's Guidefor more details.Releasing this projectReady to release a new version ofCOMPAS FAB? Here's how to do it:We use [semver][https://semver.org/], ie. we bump versions as follows:patch: bugfixes.minor: backwards-compatible features added.major: backwards-incompatible changes.Update theCHANGELOG.mdwith all novelty!Ready? Release everything in one command:invoke release [patch|minor|major]Celebrate! 💃CreditsThis package is maintained by Gramazio Kohler Research@gramaziokohlerand a long list ofcontributors.
Package: compas-fea
COMPAS FEAFinite Element Analysis for COMPAS.Finite element analysis is a numerical approach to solving a variety of problems in the sciences, mathematics and engineering fields. A continuum such as a fluid or solid volume, is discretised into a set of smaller discrete elements. For each element, data of interest, such as stresses, displacements, temperatures and so on, are found at the nodes and element integration points. The greater the number of elements used to represent the continuum, the better the numerical model will represent the original continuous solution.Thecompas_feapackage of thecompasframework seeks to aid the user, be they an architect, scientist or engineer, in creating and analysing a suitable finite element model for their problem. This is done by creating aStructureobject, to contain geometric information about the model, and then to apply loads, displacements, materials and so forth for a subsequent analysis. This construction of theStructureobject may be performed in a pure scripting manner with Python, and/or through various modules that help construct the object through present or parametrically generated geometry.Once the model has been constructed, it may be analysed through a finite element solver in the background, with the data then stored back into the original object or as raw data files. The data can then be post-processed to display the results either through standard compas viewers and applications, or with visualisation support from specific CAD or finite element software.By using thecompas_feapackage, the majority of the repetitive scripting tasks needed to perform a geometrically or structurally complex analysis are eliminated, allowing for the rapid investigation of models, with easy to use and streamlined data post-processing and visualisation support.InstallationFirst StepsQuestions and FeedbackIssue TrackerLicenseCredits
Package: compas-gmsh
COMPAS GMSHCOMPAS friendly interface for Gmsh.Installationcondacreate-ngmsh-cconda-forgecompascompas_view2--yes
condaactivategmsh
pipinstallcompas_gmshGetting StartedHave a look at some of the firstexamples in the documentation.Licensecompas_gmshprovides a COMPAS friendly interface toGmsh.Gmshis released under GPL-2.0-or-later.
Package: compas-ifc
COMPAS IFCIndustry Foundation Classes (IFC) is a data model that describes building and construction industry data. It is a platform neutral, open file format specification that is not controlled by a single vendor or group of vendors. It is an object-based file format with a data model developed by buildingSMART (formerly the International Alliance for Interoperability, IAI) to facilitate interoperability in the architecture, engineering and construction (AEC) industry, and is a commonly used collaboration format in Building information modeling (BIM) based projects. The latest IFC documentation and specification can be found athttps://ifc43-docs.standards.buildingsmart.org/.IFC is now widely adopted by industry and often the required format for BIM data exchange and project delivery. However Working direcly with IFC content is a highly complicated task, due to its multi-layered class inheritances and complex spatial heirarchies.COMPAS IFC is a COMPAS extension developed to make our lives easier. It allows us to work with IFC files in an accessible, developer-friendly and pythonic way. By creating a two-way bridge between IFC files and COMPAS data structures, we can immediately benifit from wide range of tools for geometric processing and analysing from COMPAS ecosystem. COMPAS IFC also allows us to export processed data back to valid IFC files.COMPAS IFC relies onIfcOpenShellfor lower-level entity parsing, schema retriving and file manipulations, On top of that we additionally simplify the workflow to interact with IFC contents.Some of the core features of COMPAS IFC are:Prase IFC files and inspect its entitiesTraverse IFC spatial heirarchies in a user-friendly wayView and edit IFC entity attributes and propertiesExtract geometric representations from IFC entities as COMPAS geometry and data structuresExport selected IFC entities while maintaining minimal valid spatial structureInsert new IFC entities into existing IFC files.Create entirely new IFC files from scratch with valid spatial structure (in progress)This package is still early stage of development. The repo structure is subject to change. If you have questions please do not hesitate create a new issue on github repo or contanct me directly atli.chen@arch.ethz.ch.Please see documentation at:http://compas.dev/compas_ifc/
Package: compas-igs
compas-IGScompas-IGSis an implementation ofcompas_agsfor Rhino 6+.The theoretical foundation used to build this package is available in thePublicationswebpage.Getting StartedTake a look on the Getting Started instructions and tutorials available in theGitbookpage.Questions and feedbackFor questions and feedback, read through or post something in thecompas_ags categoryof the COMPAS forum.Issue trackerIf you find a bug, please help us solve it byfiling a report.ContributingIf you want to contribute, check out ourdeveloper guidelines.Licensecompas-IGSis licensed under the MIT License. SeeLICENSE, for more information.
Package: compas-igs2
compas-IGS2compas-IGS2is an implementation ofcompas_agsfor Rhino 6+.The theoretical foundation used to build this package is available in thePublicationswebpage.Getting StartedTake a look on the Getting Started instructions and tutorials available in theGitbookpage.Questions and feedbackFor questions and feedback, read through or post something in thecompas_ags categoryof the COMPAS forum.Issue trackerIf you find a bug, please help us solve it byfiling a report.ContributingIf you want to contribute, check out ourdeveloper guidelines.Licensecompas-IGS2is licensed under the MIT License. SeeLICENSE, for more information.
Package: compas-invocations
compas_invocationsA collection of reusable pyinvoke tasksUsageImport and add tasks to a collection in your project'stasks.pyfile:import os
from invoke import Collection
from compas_invocations import style

ns = Collection(style.check, style.lint)
ns.configure(
    {
        "base_folder": os.path.dirname(__file__),
    }
)For a more complete example, check thetasks.pyof this project.
Package: compas-libigl
compas_libiglCOMPAS-compatible bindings for top-level algorithms of libigl generated with Pybind.
Many of the functions provided bycompas_libiglare based on the examples in the libigl tutorial.Installationcompas_libiglcan be installed using a combination of conda and pip.condacreate-niglpython=3.7gitcmake">=3.14"boosteigen=3.3COMPAScompas_view2--yes
condaactivateigl
gitclone--recursivehttps://github.com/BlockResearchGroup/compas_libigl.gitcdcompas_libigl
rm-rfbuild
pipinstall-e.If you have git/cmake installed, this can be omitted from the environment installation.
On Mac, don't forget to installpython.app!Libigl functionsCurrently the following functionalities of Libigl are included in the wrapperGeodesic distance calculationScalarfield isolinesQuad mesh planarizationMass matrix of triangle meshesDiscrete gaussian curvatureRay/mesh intersectionBoundary loopsHarmonic parametrisationLeast-squares conformal mapsExamplesThe use of the wrapped functions is illustrated with scripts in theexamplesfolder.
Note that the functionality of the package is not directly available in Rhino, but can be used throughcompas.rpc.LicenseLibigl (and therefore alsocompas_libigl) is licensed under MPL-2.
Package: compas-model
compas_assembly2Follow documentation, link is at the top right corner.Getting started with this projectSetup code editorOpen project folder in VS CodeSelect python environment for the projectFirst time using VS Code and on Windows? Make sure select the correct terminal profile:Ctrl+Shift+P,Terminal: Select Default Profileand selectCommand Prompt.All terminal commands in the following sections can be run from the VS Code integrated terminal.First steps with gitGo to theSource controltabMake an initial commit with all newly created filesFirst steps with codeInstall the newly created projectpip install -e .Install it on Rhinopython -m compas_rhino.installCode conventionsCode convention followsPEP8style guidelines and line length of 120 characters.Check adherence to style guidelinesinvoke lintFormat code automaticallyinvoke formatDocumentationDocumentation is generated automatically out of docstrings andRSTfiles in this repositoryGenerate the docsinvoke docsCheck links in docs are validinvoke linkcheckOpen docs in your browser (file explorer ->dist/docs/index.html)TestingTests are written using thepytestframeworkRun all tests from terminalinvoke testOr run them from VS Code from theTestingtabDeveloping Grasshopper componentsWe useGrasshopper Componentizerto develop Python components that can be stored and edited on git.Build componentsinvoke build-ghuser-componentsInstall components on Rhinopython -m compas_rhino.installPublish releaseReleases follow thesemverversioning convention.Create a new releaseinvoke release major
Package: compas-nurbs
This package is inspired by theNURBS-Pythonpackage, however uses aNumPy-based backend for better performance.Curve, andSurfaceare non-uniform non-rational B-Spline geometries (NUBS),RationalCurve, andRationalSurfaceare
non-uniform rational B-Spline Geometries (NURBS). They all built upon the classBSpline.
Coordinates have to be in 3D space (x, y, z).Please refer to theDocumentationfor details.COMPAS NURBSruns on Python x.x and x.x.Getting StartedThe recommended way to installCOMPAS NURBSis to use aAnaconda/condaenvironment:conda config --add channels conda-forge
conda create -n ENV_NAME compas
conda activate ENV_NAME
pip install compas_nurbsOnce the installation is completed, you can verify your setup.
Start Python from the command prompt and run the following:>>> import compas_nurbsYou are ready to useCOMPAS NURBS!ContributingMake sure you setup your local development environment correctly:Clone thecompas_nurbsrepository.Install development dependencies and make the project accessible from Rhino:pip install -r requirements-dev.txt
python -m compas_rhino.installYou’re ready to start working!During development, use tasks on the
command line to ease recurring operations:invoke clean: Clean all generated artifacts.invoke check: Run various code and documentation style checks.invoke docs: Generate documentation.invoke test: Run all tests and checks in one swift command.invoke: Show available tasks.For more details, check theContributor’s Guide.Releasing this projectReady to release a new version ofCOMPAS NURBS? Here’s how to do it:We usesemver, i.e. we bump versions as follows:patch: bugfixes.minor: backwards-compatible features added.major: backwards-incompatible changes.Update theCHANGELOG.rstwith all novelty!Ready? Release everything in one command:invoke release [patch|minor|major]Celebrate! 💃CreditsThis package was created by Romana Rust <rust@arch.ethz.ch>@romanarustat@gramaziokohlerChangelog0.2.0AddedAddedSurfaceArtistfor GhPythonAddedCurveArtistfor GhPythonChangedFixedDeprecatedRemoved0.1.0Initial version
Package: compas-rcf
compas_rcfpython module for MAS DFAB project Rapid Clay FormationsGetting started- for installation and update instructionsExample files- for demonstration purposesContributing- how to start working on the codeKnown issues- for things that we know don't workIssues- for unknown issues, as well as suggestions and questionsDocumentationCOMPAScompas_rcfis part is built on top ofcompas,compas_fabandcompas_rrc.Note on compatibilityInstallation of the package requires Python >= 3.6.Big parts are compatible with IronPython 2.7 (to be run inside Rhino plugin
Grasshopper).The modules that require Python >= 3.6 should raise an exception on import.
Package: compas-robots
COMPAS RobotsBasic infrastructure for working with robots in COMPAS.Getting started with this projectSetup code editorOpen project folder in VS CodeSelect python environment for the projectFirst time using VS Code and on Windows? Make sure select the correct terminal profile:Ctrl+Shift+P,Terminal: Select Default Profileand selectCommand Prompt.All terminal commands in the following sections can be run from the VS Code integrated terminal.First steps with gitGo to theSource controltabMake an initial commit with all newly created filesFirst steps with codeInstall the newly created projectpip install -e .Install it on Rhinopython -m compas_rhino.installCode conventionsCode convention followsPEP8style guidelines and line length of 120 characters.Check adherence to style guidelinesinvoke lintFormat code automaticallyinvoke formatDocumentationDocumentation is generated automatically out of docstrings andRSTfiles in this repositoryGenerate the docsinvoke docsCheck links in docs are validinvoke linkcheckOpen docs in your browser (file explorer ->dist/docs/index.html)TestingTests are written using thepytestframeworkRun all tests from terminalinvoke testOr run them from VS Code from theTestingtabPublish releaseReleases follow thesemverversioning convention.Create a new releaseinvoke release major
Package: compas-rrc
Online control for ABB robots over a simple-to-use Python interface.Main featuresProvides a simple way to interact with ABB robotsSupports futures and blocking callsBuilds on top of COMPAS FABSupports all RAPID instructions as well as custom proceduresSupports EGM activation/deactivationSupports multi-move up to 4 robotsSupports commanding multiple controllers in coordinationOpen up the Python world for ABB robotsCOMPAS RRCruns on Python 3.x as well as IronPython 2.7.RequirementsCOMPAS RRCis part of theCOMPASframework and it requires
the core library and the robotic fabrication packageCOMPAS FAB.InstallationFirst install the pre-requisites in a conda environment:NoteMake sure to changeENVIRONMENT_NAMEto a name of your choiceconda create -c conda-forge -n ENVIRONMENT_NAME compas_rrc python=3.8
conda activate ENVIRONMENT_NAMEGetting startedYou can find additional examples to get your started easily onthe compas_rrc_start repository.ContributingCheck theContributor’s Guide.CreditsThis package was created by Philippe Fleischmann <fleischmann@arch.ethz.ch>@fleischpat@ethrflChangelog1.1.0AddedPrepared github actions for continuous integrationAdded compas plugin for automatic Rhino installChangedFixedDeprecatedRemoved1.0.0Initial version
Package: compas-RV2
RhinoVAULT 2RV2 (RhinoVAULT 2) is an implementation of RhinVAULT for Rhino 6+, based on the COMPAS framework.Getting StartedRV2 is available as installable plugin for Rhino(6+).
Installation instructions are available in the docs:InstallationFirst StepsTheUser Manualis a good place to start.Questions and feedbackRV2 has a dedicatedpost category on the COMPAS forumfor questions and discussions.Issue trackerIf you find a bug, please help us solve it byfiling a report.ContributingIf you want to contribute, please contact the development team.
Package: compas-singular
compas_singularWelcome tocompas_singular, a Python library tackles topology finding of patterns, particularly singularities in structured quad meshes.
Based on thePhD research of Robin Oval, this library implements data structures for quad mesh modelling, several algorithms for topological exploration and interface with Rhino3D/Grasshopper3D.compas_singularis based on theCOMPASframework is an open-source, Python-based framework for computational research and collaboration in architecture, engineering, digital fabrication and construction.Getting StartedInstallationUpdatingRhinoFirst StepsSee theoverviewof the algorithms and tools currently proposed and try out theexamples.Questions and feedbackIssue trackerContributingChangelogLicensecompas_singularisreleased under the MIT license.