opencax / gsoc Goto Github PK
View Code? Open in Web Editor NEWGoogle Summer of Code Projects
Google Summer of Code Projects
Currently OpenSCAD uses it's own limited parser to read DXF files (2D-only) which does not support things like curves/splines. A previous GSoC project started with converting the BRL-CAD importer into a library. Goal of this project is to finish conversion by using more C++ features and fully integrating the code into OpenSCAD.
The main focus for the change is the import of DXF files as the import currently fails to read various categories of DXF files exported by other tools. Right now a complex preparation is needed to ensure drawings created in programs like Inkscape can be imported correctly in OpenSCAD.
Importing more complex drawings will need some integration with OpenSCAD features, e.g. the handling of $fn/$fa/$fs variables that define how curves are converted into the internal polygon/mesh data structures.
In addition to import()
the DXF specific modules dxf_dim()
and dxf_cross()
need to be considered as well.
The current state is tracked in openscad/openscad#3006
Medium
Mentors: Marius Kintel (IRC: kintel), Torsten Paul (IRC: teepee)
This page is dedicated to the description of the Google Summer of Code|Google Summer of Code 2019 project idea of integrating FreeCAD and BRL-CAD.
FreeCAD and BRL-CAD are very complementary applications: BRL-CAD is a powerful engine which could do with a better modeling UI, and FreeCAD has an increasingly vast modeling UI but could make great use of the support for large models that BRL-CAD can offer.
FreeCAD being highly modular, and BRL-CAD having a C/C++ API, building a BRL-CAD module for FreeCAD is totally possible. This way, it would be possible to open BRL-CAD models (that are usually called geometry databases, because they are often made of a collection of models) in FreeCAD, and it would also be possible to use FreeCAD as a modeling tool for BRL-CAD.
This project idea will require a reasonable knowledge of C/C++, and, since it involves two different applications, a versatile mind able to learn quickly and navigate between many different concepts, as they are implemented differently in both applications.
This project would be mentored commonly by both FreeCAD and BRL-CAD developers.
Such an integration could go a very long way, as both applications are very complex, and if the "wedding" works well, new possible fields of use could emerge. Also, we think this kind of inter-project integration could pave the way for more, so the possibilities are vast.
High, mostly because you have two different applications to learn and work with
Write a proposal that leverages rewrite of the existing application in the latest tech stack for frontend and backend.
We have been working on OGV for over 5 years. It started with PHP and then was revamped to meteor.js. We want to focus on the backend of OGV, making sure it works properly, converts the models properly, and basically finish a 1.0 version of OGV so we can launch it for the masses! For that, we are planning to change the legacy backend to be rewritten along with the frontend.
You can use any tech stack (react, vue) for frontend and node, c/c++ for the backend. We faced some problems like removing certain deprecated dependencies and adding new features with Meteor. We are planning to port the application and add all the features that are specified in the GitHub project board here: https://github.com/BRL-CAD/OGV-meteor/projects/1 You don't have to limit yourself to those ideas.
You're expected to propose an outcome useful to end-users. That is a broad range of possibilities that will depend on your interests and experience level. For example, you might propose focusing on the backend conversion to triangles for display (C/C++/Node.js). Or you might propose changing the backend to NURBS surfaces (C/C++) and using verbnurb or three.js (Javascript) to display them instead of triangles. Or you might propose keeping the backend the way it is and focus on front-end robustness (Vue, React), website features, or deployment infrastructure. You hopefully get the idea.
Hard
This project can be scoped medium (175h) or long (350h), depending on the amount of functionality you want to include.
LibreCAD 3 uses Travis-CI, which compiles the code, runs the unit tests and a code linter.
The system is triggered on every pull request and on new commit in the master branch.
The build script needs improvements to help reviewing the pull requests and commits.
Here are some of the problems encountered with Travis:
The current system is slow. It's exceeding the time limit of 50 minutes, which show the build as failed.
Possible improvements: faster compilation, use cache for code linting, separate the code linting from compilation...
Travis notifies the result of a build on IRC, which may be annoying for some users.
This can be improved by sending the notifications to a dedicated Zulip channel instead.
Only Linux is supported.
The current build is only done on Linux/GCC (and Linux/clang for the linter).
OS X could be tested too. It should work out of the box.
LibreCAD doesn't have publicly available binaries, so each user have to compile it before testing it.
The binaries created by Travis could be uploaded somewhere.
Related issues:
LibreCAD/LibreCAD_3#213
LibreCAD/LibreCAD_3#208
The most important task is to fix the building script, so it shows a correct result on pull requests and commits, then make it faster.
medium
Many input fields in KiCad can evaluate arithmetic expressions, taking their results as the actual inputs. This is accomplished using two parser-evaluators implemented with the Lemon Parser Generator, which we however intend to replace.
The task is to rewrite these evaluators using PEGTL, a header-only C++ template library, and compare them to what is used currently.
Both of the Lemon parsers reimplemented in PEGTL and compared to their original implementations. QA tests are implemented to check for their correctness.
Medium
175 hours
This page is dedicated to the description of the [Google Summer of Code 2019](Upgrade the documentation system) project idea of upgrading the documentation system of FreeCAD.
FreeCAD already possesses a vast documentation, written by its users and hosted on its own wiki. On each FreeCAD release, the contents of the wiki get packed into a offline documentation package which is bundled with FreeCAD. When using the "what's this?" feature, FreeCAD users can quickly get documentation about a specific tool
Additionally, this same documentation also has several translations, hosted on the same wiki and managed by a mediawiki plugin, and also counts on the source code structure and comments, automatically extracted by the doxygen tool, and hosted on https://www.freecadweb.org/api/
However there are several problems:
Additionally, the mediawiki-based documentation is more and more problematic to maintain and back up, and we are looking at transitioning to a more easily portable and redundant system like git-based wikis.
This project proposes to remedy to the main problems by:
Medium
Develop further the new GUI for BRL-CAD!
BRL-CAD has two main graphical applications called 'mged' and 'archer' which look like they were developed in the 80's and 90's respectively (because they were). We need a modern GUI, ideally using Qt.
This new GUI will need to leverage our existing libraries in a big way. This includes the C++ coreInterface ( see https://brlcad.org/wiki/Object-oriented_interfaces) or its successor MOOSE (see https://github.com/BRL-CAD/MOOSE) and LIBGED (see src/libged). The latter is basically all commands available to both mged and archer.
During past GSoCs an amazing start was made with arbalest. Based on this, the development of a GUI called 'qged' (see src/qged) was started, which you should include in your considerations too. This program implements the traditional BRL-CAD workflow under a modern Qt-based user interface.
You may propose a complete different approach, but we recommend to use arbalest as starting point for your work. Which additions would you like to program in this years GSoC? You can use the results of the former prototype CAD GUI Google Code-in tasks (http://brlcad.org/gci/data/uncategorized/, search for CAD_GUI there) for inspiration.
Keep your proposal lean and simple. The main emphasis should be on adding features and/or improvements to our next generation GUI.
An improved BRL-CAD GUI.
medium
This project can be scoped medium (175h) or long (350h), depending on the amount of functionality you want to include.
Implement bindings for the BRL-CAD functionality to Python programming language
There are long time on-going efforts to wrap BRL-CAD functionality with python code, e.g.
These projects are however still in early development stages.
A Python module which can read and write BRL-CAD databases, and provide access to their contents to read, create, and modify the objects.
This project may be of easy or medium difficulty, depending on your familiarity and expertise.
This project can be scoped medium (175h) or long (350h), depending on the amount of functionality you want to include.
Add more interactive help features for built-in functions and modules. Right now there's already a nice summary of parameters linked as cheat sheet. Scope of this projects would be to use this information in extended form and make it available in a more direct way in the editor.
Cheat sheet is integrated into the application and additional context help for built-in functions and modules is available.
Easy
The user manual for OpenSCAD is maintained at Wikibooks. This is a nice solution as everybody with a Wikipedia account can help improving it. The drawback is that it's only available online. The "Print Version" accessible there needs special work and duplicates part of the information.
It would be very useful if generating an offline version that could be shipped with OpenSCAD could be automated.
Wikipedia allows the export of data via a simple interface (https://en.wikipedia.org/wiki/Help:Export)
This is probably mainly intended to be the source for backups and/or for transferring data from one installation to another. There's big list of converters around, most seem to target the import into another wiki software but some will convert to other file formats already. (https://www.mediawiki.org/wiki/Alternative_parsers)
The manual export is easily done by calling https://en.wikibooks.org/wiki/Special:Export and entering "OpenSCAD_User_Manual" into the "Add pages from category". This exports all the text content into one big XML file.
The ideal option would be an automated way to convert this XML file into different formats. As first step, to make it usable as off-line documentation, the target would probably be either static HTML that could be shipped with OpenSCAD or maybe PDF.
It needs investigating if that actual programming is required, or if the existing tools are maybe already sufficient for that. So the specific tasks could be one of
write a script that does all the conversion and image downloading
write a simple script to just run various existing tools
go though the wiki pages of the manual and adjust some of the
text so it works nicely with some existing tool
use a tool or write a script to scrape the HTML representation from Wikibooks
something else, we did not see yet...
Ideally that should run on Linux so it could be integrated into one of the automatic build servers (e.g. Travis). A manual solution that is just started now an then would also be a nice thing.
Easy
Mentors: Marius Kintel (IRC: kintel), Torsten Paul (IRC: teepee)
libdxfrw is a library to read and write DXF files and read only DWG files.
The library is a fundamental part of LibreCAD and may become useful for our friend applications too.
Started by our valued LibreCAD contributor Rallaz the library needs some attention.
The library must be more stable, means no crash of the application if any malformed input is given.
The interface will have some kind of error handling and reporting.
More DWG content could be extracted.
medium
IfcOpenShell has a code generator that generates C++ code from the IFC schema defined in the EXPRESS language (wiki). This language allows for the definition of functions and rules that are currently not taken into account in the parsing process. These rules range from simple scalar checks like:
TYPE IfcPositiveLengthMeasure = IfcLengthMeasure;
WHERE
WR1 : SELF > 0.;
END_TYPE;
to complex turing complete functions to validate geometric constructs, like:
ENTITY IfcExtrudedAreaSolid
SUPERTYPE OF (ONEOF
(IfcExtrudedAreaSolidTapered))
SUBTYPE OF (IfcSweptAreaSolid);
ExtrudedDirection : IfcDirection;
Depth : IfcPositiveLengthMeasure;
WHERE
ValidExtrusionDirection : IfcDotProduct(IfcRepresentationItem() || IfcGeometricRepresentationItem() || IfcDirection([0.0,0.0,1.0]), SELF.ExtrudedDirection) <> 0.0;
END_ENTITY;
FUNCTION IfcDotProduct
(Arg1, Arg2 : IfcDirection)
: REAL;
LOCAL
Scalar : REAL;
Vec1, Vec2 : IfcDirection;
Ndim : INTEGER;
END_LOCAL;
IF NOT EXISTS (Arg1) OR NOT EXISTS (Arg2) THEN
Scalar := ?;
ELSE
IF (Arg1.Dim <> Arg2.Dim) THEN
Scalar := ?;
ELSE
BEGIN
Vec1 := IfcNormalise(Arg1);
Vec2 := IfcNormalise(Arg2);
Ndim := Arg1.Dim;
Scalar := 0.0;
REPEAT i := 1 TO Ndim;
Scalar := Scalar + Vec1.DirectionRatios[i]*Vec2.DirectionRatios[i];
END_REPEAT;
END;
END_IF;
END_IF;
RETURN (Scalar);
END_FUNCTION;
This GSoC proposal suggests an initial parser for these rules and an implementation in the Python, C++ or Java programming language. Python is an excellent choice for this being quick to write and expressive, yet can offer it's application in STEPcode exp2py, FreeCAD, IfcOpenShell and BlenderBIM. C++ is the language in which the core of IfcOpenShell is written, so can also be used. Java has notable parsing frameworks such as ANTLR so are also allowed if preferred by the applicant.
Implementing support for these clauses serves several purposes: (a) The automated validation of IFC building models is a crucial aspect in enabling trust in information exchanges. The current practice is that often information from other project stakeholders is neglected because of a lack of trust in the validity. (b) At the same time though, the standardization organization behind IFC realizes that the EXPRESS language is out of style and more modern approaches exist to encode schema information. A flexible parser for EXPRESS where rules and functions might serve as a transpiler to encode the body of rules in different formats. (c) Lastly, domain extensions are currently being authored around IFC by domain experts and people from academia, giving them access to a parser and validator for EXPRESS rules will help them in defining their domain rules in the schema.
The current version of the IfcOpenShell express code generator is available here https://github.com/IfcOpenShell/IfcOpenShell/tree/v0.6.0/src/ifcopenshell-python/ifcopenshell/express It uses the pyparsing parser framework. The project participant may consider switching to a more modern library such as Lark given it's out of the box support for BNF or Parsec.py if a parser generator / functional programming approach matches the taste of the applicant. The IfcOpenShell project maintainers are definitely open to replacing the current code generator with an alternative developed as part of this proposal.
The ideal outcome would be a Python implementation of an EXPRESS rule parser with a good well-structured syntax tree. Depending on the preferences of the applicant one might choose to implement functionality to apply the rules to a population model (an actual file) in Python, preferably using the IfcOpenShell-python parser, or work on code generation to bring the validation to C++.
This project will focus on the rules in the IFC schemas. Given the use of the Python programming language it will be readily applicable in FreeCAD and BlenderBIM (which both rely on IfcOpenShell for IFC parsing). The aim is though for this to be applicable much wider in the future (such as other STEP schemas) and when a general approach is taken to rewrite one AST to another maybe also other programming languages.
Programming language: Python, C++, Java (or another language of choice if agreed by mentors)
Parser libraries
Compilers / code generation
High
The applicant focusses on parsing and applying the parsed rules to a model it is expected to remain low-level functionality.
The applicant delivers a tool of higher maturity that reports meaningful data to end users.
Potential mentor(s): Thomas Krijnen @aothms
Organization website: http://ifcopenshell.org/
Communication channels: https://sourceforge.net/p/ifcopenshell/discussion/
A cabinet tool for the FreeCAD Arch workbench
An Arch/BIM tool to allow users to create automatically a wide range of cabinets for kitchens, bathrooms, storage... This project should involve research over possible cabinet types, how they are built in the real world, and what properties they should have.
A parametric cabinet object in the Arch Workbench, which is fully driven by properties, and a toolbar button (FreeCAD command) to create the object. Optionally, a friendly task panel UI to create and modify the object.
The student should have a reasonable knowledge of Python, and a basic knowledge of how FreeCAD and its parametric objects work
Medium
KiCad currently supports export to GenCAD, Gerber, Gerber X2 and IPC-D-356. These are commonly used, but many manufacturers would like the additional information contained in an ODB++ file. This includes net information, board stackup, bill of materials, embedded stroke fonts as well as standard layer data.
The ODB++ Design website provides a reference viewer to verify data output. There are many examples in the existing Gerber and GenCAD exporters to use for implementation frameworks.
Relevant Links:
An ODB++ exporter that can generate standard ODB++ files using existing v7 KiCad features.
Medium
350 hours
Create a new importer for files from any EDA software for which there is no built-in importer yet.
A non-exhaustive list of possible EDA software:
There are two FOSDEM talks around this topic to get a rough idea of the task:
In case you want to write an importer for a proprietary EDA program, you need to have legal access to this software. You can use a demo or student version if it is available, or you may have some other means of access, like your university institute (please ask them beforehand). If you are unsure about this topic, choose one of the open-source tools instead.
An importer for files from EDA software for which there was no built-in importer. Depending on the complexity, this might include board, schematic and/or library import.
Depends on the selected EDA package.
175 hours (schematic-only software like LTSpice, SIMetrix, Micro-Cap)
350 hours (software with both schematic and PCB layout)
This page is dedicated to the description of the Google Summer of Code project idea of adding BCF support to FreeCAD.
The BIM Collaboration Format (or BCF) is a file format aimed at coordinating the work of several participants in a Building Information Modeling (BIM) project. The format specifications are open and maintained by BuildingSMART, the same consortium behind the IFC file format.
The BCF format implements a series of tools to allow users to create, annotate, classify, comment, discuss and solve issues on a BIM model. It works as a thin layer containing issues related to a BIM model. The BCF file itself doesn't contain or relate explicitly to the model, which allow different people who work on a same project but with different applications to still be able to discuss and process the same issues.
This project idea proposes to implement a BCF viewer for FreeCAD. The viewer would allow to:
BCF use in the BIM industry is still at its infancy. One can think of many possible extensions, such as:
Medium
The integrated text editor improved quite a bit recently but there's still a number of features missing that are often requested and would make editing bigger projects easier.
This project is about adding more IDE style features to the OpenSCAD editor. Some of those features have already a prototype implementation so those would require review of the existing code continue from there.
Examples for useful features:
The main challenge is to select just a small number of features but implement those in a way that really improves the usage. Ideally this involves making different prototypes and including feedback from the user community.
Medium
Mentors: Marius Kintel (IRC: kintel), Torsten Paul (IRC: teepee)
Links:
The buildingSMART standard to define IFC based 'Information Delivery Specifications' (IDS) has a first version (and probably a final version around summer). It would be cool to have the ability to validate IDS against an IFC file.
The IDS standard is being developed and worked on here https://github.com/buildingSMART/IDS/blob/master/Development/
Add IFC file + IDS file and get check result back (preferably in BCF)
Only limited by your imagination....
XML, XSD restrictions and patterns.
Easy to medium (depending on knowledge about IFC)
Implement the wireframe printing algorithm.
Medium
LibreCAD 3 UI is written in Lua and Qt, using a custom file to bind the Qt methods to Lua.
This project consists of rewriting the GUI in C++.
Every GUI file should be rewritten in C++, and keep the operations written in Lua.
That implies to remove the Qt signals connections to Lua slots, and call Lua functions in C++ slots.
Direct Qt widget creation will be impossible after, so an API should be accessible to Lua plugins to create elements in the interface.
The interface can be restyled too, and its integration with the system improved.
Remove the Qt bindings to Lua.
Unit tests are expected.
medium
The SVGNest library provides an algorithm for polygon nesting. It's written in JavaScript and a C++ port of it would improve Slic3r's auto-arrange feature.
Easy
Work on the FreeCAD doxygen-generated documentation: Propose a better plan, document the modules better, make it clearer to read, etc.
The API documentaiton of FreeCAD is generated with doxygen from the docstrings contained in the source code. It is hosted on https://github.com/FreeCAD/SourceDoc . It is currently not easily readable, the modules structure doesn't list classes and functions, python functionality is not well distinguishable from C++ functionality, and many other problems.
Identify problems and possible solutions, and propose changes to the docstrings and in-source doxygen instructions to build better docs, and possibly do some css work to produce a cleaner HTML result
The student should have or build a good knowledge of doxygen, optionally be ready to do some css work too
Medium
Blender allows visual node programming, similar to Grasshopper in Rhino. Grasshopper has a really neat extension called GeometryGym which allows users to use visual node programming to generate building geometry and data using the "IFC" international standard. It's super awesome, and something like that doesn't exist yet in the open source world with only free software. So, let's create it!
Some of this is already started, so the basics are already coded, but now it needs to be tested, debugged, and a whole bunch more nodes written and tested out in experiments in generating buildings with visual nodes.
https://github.com/IfcOpenShell/IfcOpenShell/tree/v0.7.0/src/ifcsverchok is the source code, take a look, install it, and play around!
A whole bunch more nodes, and little examples of generating buildings via nodes, and getting an IFC output.
If we code it right, in the future, these nodes can be made agnostic of Blender and also work in FreeCAD (e.g. through PyFlow). So this allows multiple authoring apps to benefit from visual programming.
Medium
The IfcOpenShell API is exposed as visual nodes, and basic geometry creation nodes are related to IFC.
Proof of concept of simple visual node programming tasks are recreated with Sverchok and IFC nodes.
OpenSCAD supports extracting geometry of text based on fonts installed on the system. The existing font list gives an overview of what fonts are installed, but does not provide further help to select fonts. An improved selection window could improve the user experience by giving the user a preview of some sample text and more ways for selecting a font.
The font selection dialog is replaced with a dockable font selection window with extra functionality.
Medium
FreeCAD materials are mostly used at the moment by FEM and Arch. There begins to have too many material cards to be comfortable. They need to be organized better.
Currently, Arch, FEM and Render workbenches are already using the FreeCAD materials system, which is built on "material cards". However, the large number of current material cards turns it cumbersome to use in Arch, FEM, and in the own material editor. We need a better way to classify and select them.
Invent a handier way to classify, store and select materials, for example grouping them by category. Implement that system in Arch, FEM, Render and the material editor.
The student should have a good knowledge of Python, be ready to learn some Qt/PySide, and have learned how materials work in FreeCAD's Arch, FEM and Render workbenches, as well as the material editor.
Medium
When projects exchange data, we often need to set contractual requirements about what data we expect to see in their CAD or Building information data. The is an international standard for describing project requirements in XML called the Information Delivery Specifications (IDS).
There is a half-built webapp which allows viewing and minor editing of IDS files here: https://blenderbim.org/ifctester/
Your job would be to finish this web app, building features for more editing, drag and drop from a library of specifications, adding and removing requirements, etc.
A working example of the web application.
Easy
Rebar Addon is aimed at easing up the process of rebaring in FreeCAD. In this project, the list of rebars is provided to a user in the form of a dropdown. For eg. for reinforcing in the rectangular column by using Rebar addon, first, the user has to do create straight rebar in the four sides of the column and create stirrups along a length. But this is a very time-consuming process.
How to solve the problem?
There should be a dialog box where a user will add all the detail of reinforcing (like number of stirrups, a diameter of the stirrup, number of straight rebars etc.) at once and click on the Ok
button. This will create reinforcement in the structural element by using the core functionality of Rebar addon.
For more details: amrit3701/FreeCAD-Reinforcement#9
https://brlcad.org/wiki/User:Amritpal_singh/gsoc_proposal
Medium
The Altium importer lacks import of DRC rules. There is a powerful query language defined in Altium, which has to be transformed to KiCad compatible DRC rules.
The task is to write an parser of Altium DRC rules in PEGTL, a header-only C++ template library, and then transform the rules into semantically equivalent KiCad DRC rules.
Altium importer supports import of DRC rules.
Medium
175 hours
Allow users to place and move support pillars by clicking in the 3D GUI.
Medium/Hard
Design a FreeCAD library tool that fetches the content online, without the need to download the whole library
FreeCAD possesses a vast library of parts submitted by users, hosted on https://github.com/FreeCAD/FreeCAD-library . This library is huge (> 1.5Gb) and currently the only way to use it is by installing (downloading) it entirely from the Addons Manager. We need a new tool that is able to access both an offline or online version of the library (downloaded on your computer or hosted on a git platform such as github or gitlab) and allow users to browse the contents and download and place objects in their current model. The tool shouldn't depend on a sole git platform as this library could be moved to some other platform in the future.
Optionally, it could also allow users to upload models.
A new FreeCAD UI tool
The student should have a good knowledge of Python or C++, and learn how to build interface tools with Qt/PySide/QtCreator
Medium
This idea now happens on the FreeCAD repo at FreeCAD/FreeCAD#5764
FreeCAD is a feature-based parametric modeling system, hence different modeling steps depend on one or multiple previous steps. Each step is at the same time a tool/operation, and a geometrical object, resulting from that operation. This mix of operation and object is called a feature. Direct modeling, often presented as the opposite of parametric modeling, allows to graphically move vertices, push or pull faces and edges to modify the geometry of an object.
Watch an introduction to direct modeling on https://www.youtube.com/watch?v=RMrvjAPxyN0
The two concepts could however easily coexist in FreeCAD. Each operation performed via direct modeling could be stored into a new feature, that would successively modify the previous object by adding transformations, such as a displacement of a vertex, an edge, or a face, or extrusion of a certain face.
This GSoC project aims at throwing the bases of the necessary feature(s) to hold such transformations as parameters, and the 3D manipulators to allow the user to modify an existing 3D object by clicking and dragging on the screen.
Since direct modeling is a huge area in constant evolution, the work done in this GSoC will only cover a small part of it. But if the bases are done right, extending them will be easy and could develop very far.
Hard
appleseed is rendering infrastructure used to make pretty pictures. Make it shoot rays at our native geometry with our ray trace library.
Check out appleseed here: https://appleseedhq.net
appleseed has a procedural rendering method where you can use a different ray tracer to report where geometry exists and does not exist. BRL-CAD has a robust ray tracing library. Make them work together!
You'll want to propose a project that combines them into some meaningful manner, like creating a new 'art' command line application, based on BRL-CAD's 'rt' command, that uses appleseed. That would make it magically work with many other BRL-CAD features.
Note that some preliminary work is available to help you get started and make faster progress as this is a high priority project for BRL-CAD. This project has MAJOR impact potential!
A new renderer that utilizes BRL-CAD's LIBRT ray tracing library and appleseed.
Integrate with appleseed's GUI or implement features of appleseed's GUI for BRL-CAD.
medium
Often, construction firms need to visualise animations of construction sequencing. A project timeline will be created, and related to individual model elements. For example, when a concrete slab is poured, it is linked to a 3D object called a slab. We need the ability to automatically generate animations from Blender where objects appear / disappear in various different ways when they start / end their task in the project timeline. The systems for describing project timelines is already in place, so now we need a little animation generator!
A series of small scripts that take objects and can automatically animate the visibility, locations, or staggered appearances of building elements, as well as sub elements, and basic scripts that correlate real world time to animation frames, and frames per second, and generate an animated timeline bar in various styles.
This animation system can be then used from BIM models either in Blender, FreeCAD, or via other software altogether, so it has quite a large impact on the ecosystem.
Easy
Utilize cache coherency and parallelization techniques in BRL-CAD's ray tracing pipeline, and demonstrate graphically.
BRL-CAD has one of the oldest and fastest parallel ray tracing implementations around but we don't currently leverage modern techniques that minimize context switching and data access. With implicit geometry and constructive solid geometry (CSG) Boolean operations, we also have a very specific set of validation and performance challenges.
Your project is to help make the pipeline more data-coherent using ray bundling, cache-coherent processing, and OpenCL. Currently, the ray tracer evaluates one ray at a time (in parallel). There is experimental work with OpenCL in a branch.
Your primary objective for this project is to make the ray tracer evaluate groups of rays at a time (e.g., 32x32 "postage stamps") coherently, calculate and demonstrate changes made to performance, and get ray tracing via OpenCL working. A secondary stretch objective is to demonstrate performance graphically using one of several options we've explored in the past (OSPRay, O3DE, and Qt).
Your proposal should be aware of, improve upon, and/or incorporate previous year efforts:
Demonstrate improved ray tracing performance via bundling and OpenCL. Demonstrate performance graphically through a prototype interactive GUI (using OSPRay, O3DE, or Qt).
hard
The current STEP exporter is a standalone executable written in poorly-structured code that duplicates the 3D Viewer functionality and has its own PCB file parser. This makes the exporter sometimes give different results than in the 3D Viewer, and makes the STEP code overall difficult to maintain. We need a new STEP exporter that is based on the same code as the 3D Viewer and is integrated in the Pcbnew executable
Relevant issues:
The STEP exporter is based on the same code as the 3D Viewer and is integrated into the Pcbnew executable.
Medium
350 hours
Implement the prerequisites for NURBS editing in BRL-CAD's GUIs
BRL-CAD has support for raytracing of NURBS surfaces implemented, but they are handed over as BLOBs to the openNURBS library. Beyond basic operations such as rotation and translation, the BRL-CAD core has no ability to edit them. This project would implement support for editing NURBS curves and surfaces in the BRL-CAD core, thus creating the prerequisites to handle them with higher level (i.e. GUI) tools.
See this task's description in former GSoCs for some more information: https://brlcad.org/wiki/NURBS_Editing_Support
The key-feature would be to have ged command(s) that lets you build NURBS objects from scratch. This could be done by having a declarative ASCII description of these entities and/or wrapping the openNURBS library by a scripting language.
Describe in your proposal which approach you want to use and why. You may let inspire you by solutions in other programs:
Implementing the necessary logic for NURBS handling in librt, libbrep, and libged
Implementing a visual NURBS editor in a BRL-CAD GUI (mged, Archer, Arbalest)
medium
long (350h)
The current rendering infrastructure is scattered around with various bits partially belonging to external packages (CGAL, OpenCSG). Also, we're currently using immediate-mode OpenGL in some places. This is suspected to degrade rendering performance of large models.
The existing code should be refactored and rewritten, preferably by implementing or using an existing rendering/scenegraph framework. In addition to better OpenGL support and performance, care should be taken to use modern OpenGL so that the new code code be ported to GLES2 in the future.
Supporting GLES2 opens up much more possibilities like WebGL and native support for ARM Linux platforms that usually only provide GLES2 implementation.
Medium to Hard
Mentors: Marius Kintel (IRC: kintel), Torsten Paul (IRC: teepee)
See https://github.com/openscad/openscad/wiki/Information-About-Other-Frameworks
The Slic3r GUI is currently coded in Perl using wxWidgets and our goal is to have it ported to C++. The wxWidgets API is almost identical between Perl and C++, so it's an easy task. There are a couple things where we use the dynamic features of Perl which are trickier and interesting to port.
Easy
FreeCAD is a parametric 3D modeling system, and has many different workbenches to adapt to various 3D modeling workflows. Parametric modeling means that a design feature (extrusion, revolution, chamfer ...) can be modified after construction by changing its internal parameters (length, angle, distance...). When designing complex models, it is impossible to know in advance the correct parameters of a design feature, and changing parameters after construction is a fundamental aspect of FreeCAD, and any parametric design tool.
In order to change the parameters after construction, it is mandatory to know by how much those parameters needs to be changed. In the case of the design of a single part, it is mostly possible to follow the design history, and re-calculate the resulting cumulated dimensions, which allows to infer by how much a given parameter needs to be changed in order to achieve the desired result.
In the case of assemblies, there is no single design history, the dimensions between geometries is the result of parameters in individual parts and also of parameters in the assembly constraints. Therefore, in order to know by how much a given parameter needs to be modified it is mandatory to be able to measure relevant dimensions of the resulting design, after all assemblies have been done.
This GSoC propsal aims to build a unique measurement tool that would be both powerful and practical to use, and would recognise traditional 3D geometries, but also the new geometries that v0.19 of FreeCAD has introduced: App::Link and Datum objects.
FreeCAD has, as of v0.19, two such measure tools (In Manipulator WB and in Part WB), but unfortunately none of them has the level of usefulness found in other similar 3D CAD systems. The starting point of this project would be to analyse both of them, isolate in the code the useful tools, and wrap them into a usable Qt dialogue window.
In the existing Manipulator WB, study the caliper tool (Python):
https://github.com/easyw/Manipulator/blob/master/Caliper.py
If possible, in the existing Part WB, study the measurement tools source code (C++):
https://github.com/FreeCAD/FreeCAD/blob/master/src/Mod/Part/Gui/TaskDimension.cpp
Propose to the forum/community several UI design mock-ups to validate the desired work-flow. In essence, there are two possible approaches, both having their advantages and drawbacks:
a very intelligent tool that would infer from the user selection all possible parameters, and show them in a user-friendly manner. The user then has to find in all the bunch of stuff the information he wants.
or, completely opposite, present to the user a UI with the list of possible measurement tools (distance, angle, length, diameters, dist-X, dist-Y...) and display as result only the information the user wanted.
Code the agreed-on UI in Python-Qt, either in QtDesigner or as a pure Python file
add the back-end measurement functions and connect them to the UI
this tool should recognise 3D geometries, linked geometries and datum geometries.
The ideal outcome would be to have a unique toolbar button that would open the measurement tool dialogue, which would then allow the user to measure what he needs, and that would be closed when the user has finished so it doesn't clutter the screen.
A good measurement tool will be used by 100% of FreeCAD users, therefore the visibility of those implementing it will be enormous, and will open them all the doors of the FreeCAD community.
Medium
LibreCAD 3 uses Cairo for rendering. For users with high-resolution screens, Cairo is not convenient because of a slowness, due to a bad integration with Qt and a missing caching system.
The project consists of replacing Cairo with OpenGL in LibreCAD 3.
LibreCAD 3 was designed to have multiple rendering engines without major modifications to its core. It uses a painter system, and this project consists of writing a subclass of the painter, using OpenGL methods.
This project was already started by Kartik Kumar, who has made a very good partial implementation of the painter, and is currently integrating it with LibreCAD.
The first step is to finish the integration of this painter, then implement the missing methods.
This painter should have more features, as:
At the end, this project should be ready to replace the Cairo painter.
The implementation has to use OpenGL Vertex Buffer Objects, and keep the entities in cache as long as they are not modified.
hard
The good but unmaintained Boost.Voronoi library has a couple minor issues affecting Slic3r's results. Interesting task for learning the Voronoi algorithm and how to troubleshoot a computational geometry issue.
Medium
The EAGLE importer for schematic and PCB is out of date. It should be refactored or rewritten to follow the architecture of CADSTAR or Altium importers where we first load to domain-level objects and then convert to KiCad objects.
Epic: https://gitlab.com/groups/kicad/code/-/epics/40
A modernized EAGLE importer structured like the Altium and CADSTAR parsers.
Easy
175 hours
The bSDD, or buildingSMART Data Dictionary is an international standards based shared database and API for product manufacturers and organisations to share standardised metadata for building elements, like doors, windows, and other assets that make up our built environment. Currently, there is no free software library available to access this API. Building such an API library, along with a proof of concept UI in either Blender or FreeCAD will allow multiple free software to start leading the way in high quality building data.
A Python library is written that connects to the bsDD REST API.
Integration into Blender and / or FreeCAD as a UI and workflow in building 3D models of buildings.
Easy
Basic support for annotations was added in 2017 and 2019. Take that support to the next level!
Annotations are labels, dimensions, tolerances, and other notes that you can specify on geometry or they can be simple notes that are displayed.
BRL-CAD already has an "annotation primitive" that holds basic annotation information (labels) but it's very basic and not yet usable. Your proposal should explain in detail what annotations you intend to prioritize first and how you'll go about adding that support.
The end result should hopefully be something like annotation examples you can find on the web (e.g., https://www.3dcadworld.com/leveraging-3d-cad-data/ ).
There's not enough time to implement a complete GD&T system during GSoC so be sure to plan to implement, test, and demonstrate one feature at a time in your proposal.
hard
long (350h)
The STEP format is widely used in the industry to transfer CAD data between different systems. Currently OpenSCAD does not support STEP import or export. Adding STEP export would open up a number of new usecases or simplify the workflow as no external conversion tools are needed to convert to STEP. This includes the design of 3D models for other CAD tools, e.g. for KiCAD where STEP models are used to render 3D representations of PCBs. Other use cases are for manufacturing where sometimes only STEP files are accepted as input, e.g. for CNC milling services.
The main focus of this project is to get the ground work done for exporting more detailed models, as opposed to just exporting the fully rendered single mesh which is the normal case right now.
Topics that need to be solved
Hard
Long (350h)
Known libraries:
Constructive solid geometry (CSG) is one of the two core modeling techniques provided by OpenSCAD. Currently, 3D CSG operations are handled using the CGAL library. 2D CSG operations are handled using the Clipper library.
There is a large number of papers about the topic of CSG and related algorithms. This project is intended to provide an overview about available algorithms, their properties and a thorough comparison.
Medium to High
Mentors: Marius Kintel (IRC: kintel), Torsten Paul (IRC: teepee)
The "BCF" system, or BIM Collaboration Format system is an international standard to track issues in building design and coordination. It's similar to issue tracking on software projects, just like this one, so it stores things like issue titles, assigned responsibilities, tags, and issue comments. It also contains discussions about issues in 3D building models, like section planes coordinates, highlighting 3D geometry, and camera views. There are two ways BCF issues can be exchanged - either manually through files ending in the .bcf extension, or via an API.
There is already a library which handles reading and writing these files through the .bcf extension, but not via the API. This is where we need your help! Help build one which connects to this REST API.
The existing bcf library will get the ability to connect to BCF APIs and read and write BCF related data.
https://github.com/IfcOpenShell/IfcOpenShell/tree/v0.6.0/src/bcf
The first step is to add functionality for the bcf library to interface with BCF-XML v3.0. Ideally, we should build a small mini server too.
Resources:
Test existing server details will be provided.
Integration into Blender or FreeCAD
Easy
Command-line tools to manipulate FreeCAD preferences from outside FreeCAD, so one could install & configure fully via script.
Currently it is possible to manipulate FreeCAD preferences options via the Edit->Preferences menu, or via the parameters editor found under the Tools menu. It would be handy to add a way to edit these parameters from scripts, so a FreeCAD installation could be fully automated, including setting preference options. One way to do it could be by adding other command-line options to the FreeCAD executable (which must be done in C++), another maybe more flexible way could be an external command-line tool (which can be coded in any language, but preferably Python), that would create/manipulate the .cfg files where FreeCAD preferences are stored.
A command-line tool that allows to create, modify or delete FreeCAD preference parameters
The student should have a good knowledge of Python or C++, and learn how the preferences system of FreeCAD works
Medium
Implement techniques for non-planar printing.
Medium
A declarative, efficient, and flexible JavaScript library for building user interfaces.
๐ Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
An Open Source Machine Learning Framework for Everyone
The Web framework for perfectionists with deadlines.
A PHP framework for web artisans
Bring data to life with SVG, Canvas and HTML. ๐๐๐
JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
Some thing interesting about web. New door for the world.
A server is a program made to process requests and deliver data to clients.
Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Some thing interesting about visualization, use data art
Some thing interesting about game, make everyone happy.
We are working to build community through open source technology. NB: members must have two-factor auth.
Open source projects and samples from Microsoft.
Google โค๏ธ Open Source for everyone.
Alibaba Open Source for everyone
Data-Driven Documents codes.
China tencent open source team.