opencax / gsoc Goto Github PK

Outline

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.

Project Properties

Skills

• C++/wxWidgets

Difficulty

Easy

Additional information

Outline

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.

Details

• Port the expression evaluator used in unit binders (grammar)
• Compare the new evaluator to the original one.
• Do the same for the expression evaluator used in DRC rules (grammar)
• Write QA tests for both evaluators

Expected Outcome

Both of the Lemon parsers reimplemented in PEGTL and compared to their original implementations. QA tests are implemented to check for their correctness.

Project Properties

Skills

• C++
• Parser generators

Difficulty

Medium

Size

175 hours

Additional Information

• Potential mentors:
  • Mikolaj Wielgus
• Organization website: https://kicad.org
• Communication channels:
  • [email protected]
  • Discord channel

Outline

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.

Details

• Map out Altium DRC rules and the semantically equivalent rules in KiCad
• Write a parser for Altium DRC rules in PEGTL
• Write a transformer which converts the input into KiCad compatible DRC rules
• Write QA tests for the parser and transformer

Expected Outcome

Altium importer supports import of DRC rules.

Project Properties

Skills

• C++
• Parser generators
• Basic knowledge of EDA software concepts

Difficulty

Medium

Size

175 hours

Additional Information

• Potential mentors:
  • Thomas Pointhuber
• Organization website: https://kicad.org
• Communication channels:
  • [email protected]
  • Discord channel

Outline

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

Details

Relevant issues:

• https://gitlab.com/kicad/code/kicad/-/issues/2269
• https://gitlab.com/kicad/code/kicad/-/issues/9099

Expected Outcome

The STEP exporter is based on the same code as the 3D Viewer and is integrated into the Pcbnew executable.

Project Properties

Skills

• C++
• 3D modelling
• OpenCascade

Difficulty

Medium

Size

350 hours

Additional Information

• Potential mentors:
  • Mikolaj Wielgus
• Organization website: https://kicad.org
• Communication channels:
  • [email protected]
  • Discord channel

Outline

Write a proposal that leverages rewrite of the existing application in the latest tech stack for frontend and backend.

Details

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.

Checklist to write proposal for OGV

• Download and clone OGV from https://github.com/BRL-CAD/OGV-meteor
• Setup and Run OGV on your local machine.
• Fork OGV repo
• Understand the flow of existing application
• Talk to mentors
• Choose list of issues that you would like to solve this summer
• Make a detailed weekly implementation plan
• Share your proposal with your mentors
• Submit it to the GSoC website

Expected Outcome

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.

Project Properties

Skills

• JavaScript (Vue, React)
• Node.js (required)
• C/C++ (optional)
• Verbnurb (optional)
• Three.js (optional)

Difficulty

Hard

Size

This project can be scoped medium (175h) or long (350h), depending on the amount of functionality you want to include.

Additional Information

• Potential mentor(s):
  Amanjot Singh
  Daniel Rossberg
• Organization website: https://brlcad.org
• Communication channels: https://brlcad.zulipchat.com

Outline

Command-line tools to manipulate FreeCAD preferences from outside FreeCAD, so one could install & configure fully via script.

Details

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.

Expected Outcome

A command-line tool that allows to create, modify or delete FreeCAD preference parameters

Project Properties

Skills

The student should have a good knowledge of Python or C++, and learn how the preferences system of FreeCAD works

Difficulty

Medium

Additional Information

• Potential mentor(s): Yorik
• Organization website: https://freecadweb.org
• Communication channels: https://https://forum.freecadweb.org

Outline

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.

Details

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

Expected Outcome

• OpenSCAD supports reading of 2D DXF files exported by other programs (e.g. Inkscape) without special preparation before the export (e.g. convert curves to straight lines)
• Optional: Support for reading 3D DXF

Project Properties

Skills

• Programming language is C++
• Convert C code to C++
• Add test cases with files using the new features to allow regression testing

Difficulty

Medium

Additional Information

Mentors: Marius Kintel (IRC: kintel), Torsten Paul (IRC: teepee)

• BRL-CAD importer - see http://sourceforge.net/p/brlcad/code/HEAD/tree/brlcad/trunk/src/conv/dxf/ also there's currently a project going on to provide file-formats/converters as separate library

Outline

Implement techniques for non-planar printing.

Project Properties

Skills

• C++

Difficulty

Medium

Additional information

• slic3r/Slic3r#3442

Outline

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.

Details

• make it more bullet proof, feeding wrong formatted files should not crash the application
• improve the interface, the application need more information when read or write fails
• improve DWG support, not all entities are supported yet

Expected Outcome

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.

Project Properties

Skills

• C++

Difficulty

medium

Additional Information

• Potential mentor(s): Armin lordofbikes
• Organization website: https://librecad.org/
• Communication channels: https://librecad.zulipchat.com/

Outline

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.

Details

• Rewrite the parser to use domain objects like in the Altium and CADSTAR parsers
• Check for correctness and completeness, including current EAGLE version features
  • E.g. import EAGLE multiple sheet schematics (issue)
• Add support for Fusion360 import (should be the same data format, just inside an archive)
• Write QA tests for all major parts of the importer

Epic: https://gitlab.com/groups/kicad/code/-/epics/40

Expected Outcome

A modernized EAGLE importer structured like the Altium and CADSTAR parsers.

Project Properties

Skills

• C++
• Basic knowledge of EDA software concepts

Difficulty

Easy

Size

175 hours

Additional Information

• Potential mentors:
  • Roberto Fernandez Bautista
  • Thomas Pointhuber
• Organization website: https://kicad.org
• Communication channels:
  • [email protected]
  • Discord channel

This page is dedicated to the description of the Google Summer of Code project idea of adding BCF support to FreeCAD.

Outline

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:

• Open BCF files
• View the different issues with their comments and images (screenshots)
• Navigate in a FreeCAD model to a camera position stored in the BCF file
• Comment, annotate, classify and tag issues
• Create new issues, save screenshots and camera position
• Save BCF files
• If time permits, explore the possibilities of server-based BCF serving (API)

Details

• Get familiar with FreeCAD and the current state of BIM tools
• Get familiar with [https://en.wikipedia.org/wiki/PySide PySide] and Qt
• Get familiar with the BCF format, gather a series of test files
• Implement the different functions needed to interact with BCF files and data
• Implement a Graphical User Interface to these functions

Expected Outcome

• Documentation. Like all open-source projects, it is of uttermost importance to document a lot everything you do. This allows for other people to take on and extend your work more easily.
• A complete, working GUI application, that works as a plugin/addon inside FreeCAD.

Future Possibilities

BCF use in the BIM industry is still at its infancy. One can think of many possible extensions, such as:

• Connecting with other (open-source) communication structures: forums, chat/messaging systems, etc...
• Connecting with other issues tracking systems

Project Properties

Skills

• Programming language: Python + PySide
• Knowledge of BIM modeling and workflows is a plus, or be ready to practice!

Difficulty

Medium

Additional Information

• Potential mentors: Yorik
• Link to this idea on the FreeCAD wiki: https://www.freecadweb.org/wiki/BCF_support
• The GSOC 2019 thread on the FreeCAD forum. Come chat with us there if you're interested! https://forum.freecadweb.org/viewtopic.php?f=8&t=32284

Outline

A cabinet tool for the FreeCAD Arch workbench

Details

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.

Expected Outcome

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.

Project Properties

Skills

The student should have a reasonable knowledge of Python, and a basic knowledge of how FreeCAD and its parametric objects work

Difficulty

Medium

Additional Information

• Potential mentor(s): Yorik
• Organization website: https://freecadweb.org
• Communication channels: https://https://forum.freecadweb.org

Outline

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.

• bSDD API prototype: https://bs-dd-api-prototype.azurewebsites.net/swagger/index.html
• Important reading / research about how the bSDD is meant to work: https://github.com/buildingSMART/bSDD/tree/master/2020%20prototype
• Some tips on getting started: https://github.com/buildingSMART/bSDD/blob/master/2021%20Hackathon/tutorial.md

Expected Outcome

A Python library is written that connects to the bsDD REST API.

Future Possibilities

Integration into Blender and / or FreeCAD as a UI and workflow in building 3D models of buildings.

Skills

• Python knowledge
• Knowledge about how to connect to APIs, including how a REST API works
• (Optional) basic Blender or FreeCAD experience

Difficulty

Easy

Additional Information

• Potential mentor(s): Dion Moult
• Organization website: https://ifcopenshell.org
• Communication channels: https://community.osarch.org , ##architect on Freenode , and https://github.com/IfcOpenShell/IfcOpenShell/issues

Outline

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.

Details

• Convert the cheat sheet information into machine readable format
• Find a way to generate the existing HTML format based on the core data
• Add context help to editor giving help for built-in functions and modules, e.g. by adding formatted help output to the console window, including the links to further documentation like the language manual on Wikibooks

Expected Outcome

Cheat sheet is integrated into the application and additional context help for built-in functions and modules is available.

Project Properties

Skills

• Programming language is C++
• GUI programming with the Qt framework

Difficulty

Easy

Additional Information

• Potential mentor(s): Marius Kintel (IRC: kintel), Torsten Paul (IRC: teepee)
• Organization website: https://www,openscad.org/

Outline

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.

Details

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

Expected Outcome

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.

Project Properties

Skills

• Shell
• C++

Difficulty

medium

Additional Information

• Potential mentor(s): Florian
• Organization website: https://librecad.org/
• Communication channels: https://librecad.zulipchat.com/

Outline

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!

Details

Expected Outcome

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.

Future Possibilities

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.

Skills

• Basic knowledge of the principles of animation (keyframing)
• Basic Blender animation (you can do some tutorials and get up to speed pretty quick)
• Python
• Artistic sense! We should offer beautiful and elegant animations!

Difficulty

Easy

Additional Information

• Potential mentor(s): Dion Moult
• Organization website: https://ifcopenshell.org
• Communication channels: https://community.osarch.org , ##architect on Freenode , and https://github.com/IfcOpenShell/IfcOpenShell/issues

Outline

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.

Details

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.

Expected Outcome

• Cleaner rendering code
• Better support and better responsiveness for bigger models
• Optional: Support for ARM platforms using GLES2 (e.g. Raspberry Pi)

Project Properties

Skills

• Programming language is C++
• Knowledge of OpenGL and GLES v2
• Ability to read and readiness to refactor existing code

Difficulty

Medium to Hard

Additional information

Mentors: Marius Kintel (IRC: kintel), Torsten Paul (IRC: teepee)

See https://github.com/openscad/openscad/wiki/Information-About-Other-Frameworks

Related issues on Github

• Speed up OpenGL 3d mesh drawing significantly by batching whole polyheda #675
• Improve GUI responsiveness for complex objects in preview mode #418
• Display of 2-dim objects #362
• build problems with libgles2 #292
• Progressive display of rendered components #64
• Provide antialias / multisampling settings for the 3d view #1769

Further functionality which could be enabled by this

• GUI object inspection (e.g. highlight bbox, size of imported STLs)
• Pick object in 3D window and highlighting in the code
• Pick object in the code and highlight in the 3D window

Outline

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.

Details

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.

Expected Outcome

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++.

Future Possibilities

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.

Project Properties

Skills

Programming language: Python, C++, Java (or another language of choice if agreed by mentors)

Parser libraries

Compilers / code generation

Difficulty

High

Size

Medium (175h)

The applicant focusses on parsing and applying the parsed rules to a model it is expected to remain low-level functionality.

Long (350h)

The applicant delivers a tool of higher maturity that reports meaningful data to end users.

Additional Information

Potential mentor(s): Thomas Krijnen @aothms

Organization website: http://ifcopenshell.org/

Communication channels: https://sourceforge.net/p/ifcopenshell/discussion/

Outline

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++.

Details

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.

Expected Outcome

Remove the Qt bindings to Lua.

Unit tests are expected.

Project Properties

Skills

• C++
• Lua
• Qt

Difficulty

medium

Additional Information

• Potential mentor(s): Florian
• Organization website: https://librecad.org/
• Communication channels: https://librecad.zulipchat.com/

This idea now happens on the FreeCAD repo at FreeCAD/FreeCAD#5764

Outline

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.

Details

• Get familiar with OpenCasCade, FreeCADs geometric modeling kernel, and understand the geometry structure, and how complex 3D objects are constructed.
• Get familiar with Coin, FreeCADs 3D display manager, and understand how to create manipulators and interact with the 3D scene.
• Understand how FreeCADs parametric objects (features) are constructed and work
• Study and document existing direct modeling applications and techniques through available online videos and identify potentially useful direct modeling operations to be performed in FreeCAD. Study which pieces of information each of these operations requires, and how to store that information using FreeCAD's available parameters.
• Throw the bases of a feature, or a family of features, that can hold the necessary information, and perform the transformations. This can be done in either C++ or Python, or, ideally, a C++ core extensible in Python.
• Throw the bases of a manipulator, or family of manipulators, to allow the user to perform transformations by pushing and dragging on-screen, and experiment with ergonomy and usability. This can be done in either C++ or Python.

Expected Outcome

• A documentation of the various possible and useful direct modeling operations that should be performable in FreeCAD, and how each of them would translate into parametric objects (features).
• An implementation of a base feature, or family of features in FreeCAD, that can perform basic operations (proof of concept), that can be easily extended to support more operations in the future
• Experiments and/or implementation of a Coin manipulation system, that would provide the FreeCAD user with nice and ergonomic ways to interact with the geometry and perform transformations. This could also benefit other areas of FreeCAD.

Future Possibilities

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.

Project Properties

Skills

• Programming language C++ or Python
• Good understanding and use of APIs from FreeCAD and OpenCasCade
• Knowledge of 3D modeling, topology and computational geometry is a plus

Difficulty

Hard

Additional Information

• Potential mentors: Yorik
• Link to this page on the FreeCAD wiki: https://www.freecadweb.org/wiki/Direct_modeling_tools
• The GSOC 2019 thread on the FreeCAD forum. Come chat with us there if you're interested! https://forum.freecadweb.org/viewtopic.php?f=8&t=32284

Outline

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.

Details

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.

Expected Outcome

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.

Future Possibilities

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.

Project Properties

Skills

• Programming language Python
• Programming UI environment Qt, Pyside
• Reading and understanding existing FreeCAD code

Difficulty

Medium

Additional Information

• Potential mentor(s): Zolko, easyw-fc
• Organization website: https://www.freecadweb.org/
• Communication channels: FreeCAD forum "Announcements & Features" : https://forum.freecadweb.org/viewforum.php?f=9

Outline

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.

Expected Outcome

A working example of the web application.

Project Properties

Skills

• HTML, CSS, and vanilla Javascript (i.e. no frameworks).

Difficulty

Easy

Additional Information

• Potential mentor(s): Dion Moult
• Organization website: https://ifcopenshell.org
• Communication channels: https://community.osarch.org , ##architect on Freenode , and https://github.com/IfcOpenShell/IfcOpenShell/issues

Outline

Implement bindings for the BRL-CAD functionality to Python programming language

Details

There are long time on-going efforts to wrap BRL-CAD functionality with python code, e.g.

• https://github.com/kanzure/python-brlcad
• https://github.com/nmz787/python-brlcad-tcl

These projects are however still in early development stages.

Expected Outcome

A Python module which can read and write BRL-CAD databases, and provide access to their contents to read, create, and modify the objects.

Project Properties

Skills

• C/C++
• Python

Difficulty

This project may be of easy or medium difficulty, depending on your familiarity and expertise.

Size

This project can be scoped medium (175h) or long (350h), depending on the amount of functionality you want to include.

Additional Information

• Potential mentor(s):
  Daniel Rossberg
  Sean Morrison
• Organization website: https://brlcad.org
• Communication channels: https://brlcad.zulipchat.com

Outline

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.

Project Properties

Skills

• C++

Difficulty

Easy

Additional information

• slic3r/Slic3r#3237

Outline

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.

Details

The IDS standard is being developed and worked on here https://github.com/buildingSMART/IDS/blob/master/Development/

Expected Outcome

Add IFC file + IDS file and get check result back (preferably in BCF)

Future Possibilities

Only limited by your imagination....

Project Properties

Skills

XML, XSD restrictions and patterns.

Difficulty

Easy to medium (depending on knowledge about IFC)

Additional Information

• Potential mentor(s): buildingSMART International
• Organization website: https://github.com/buildingSMART/IDS/
• Communication channels: [email protected]

Outline

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!

Expected Outcome

A whole bunch more nodes, and little examples of generating buildings via nodes, and getting an IFC output.

Future Possibilities

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.

Project Properties

Skills

• Python
• Knowledge of visual programming (knowledge with Grasshopper / Sverchok super useful!), if not, get ready to watch tutorials on them!
• Basic Blender knowledge

Difficulty

Medium

Size

Medium (175h)

The IfcOpenShell API is exposed as visual nodes, and basic geometry creation nodes are related to IFC.

Long (350h)

Proof of concept of simple visual node programming tasks are recreated with Sverchok and IFC nodes.

Additional Information

• Potential mentor(s): Dion Moult
• Organization website: https://ifcopenshell.org
• Communication channels: https://community.osarch.org , ##architect on Freenode , and https://github.com/IfcOpenShell/IfcOpenShell/issues

Outline

Basic support for annotations was added in 2017 and 2019. Take that support to the next level!

Details

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.

Expected Outcome

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/ ).

Future Possibilities

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.

Project Properties

Skills

• C/C++
• Vector math

Difficulty

hard

Size

long (350h)

Additional Information

• Potential mentor(s): Daniel Rossberg
• Organization website: https://brlcad.org
• Communication channels: https://brlcad.zulipchat.com

Outline

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.

Details

• Survey existing CSG algorithms
• Compare properties of the algorithms
• Implement prototypes that could be tested inside the OpenSCAD framework
• Evaluate how more advanced modeling techniques could be realized with each algorithm (e.g. minkowski sums, convex hulls)

Future Opportunities

• Smoothing/fillets of intersection edges
  • http://implicitcad.org
  • http://www.iquilezles.org/www/articles/smin/smin.htm

Expected Outcome

• A document/paper containing the CSG algorithm survey and how it relates to OpenSCAD-specific issues.
• One or more prototype implementations integrated with OpenSCAD to demonstrate possible improvements

Project Properties

Skills

• Programming language is C++
• Admiration for math and algorithms
• Good understanding of computational geometry
• Ability to read and understand research papers
• Systematic strategy to collect and organize information

Difficulty

Medium to High

Additional information

Mentors: Marius Kintel (IRC: kintel), Torsten Paul (IRC: teepee)

CSG Research

• http://liris.cnrs.fr/mepp/
• MEPP: Exact and Efficient Booleans for Polyhedra
• Gilbert Bernstein and Don Fussell: Fast, Exact, Linear Booleans
• Sebastian Steuer: Methods for Polygonalization
  of a Constructive Solid Geometry Description in Web-based Rendering Environments

Other papers

• 3D Delaunay Triangulation on the GPU (http://www.comp.nus.edu.sg/~tants/gdel3d.html)

Existing libraries or software

• Cork - by Gilbert Bernstein
• libigl - blog
• Carve (see also pyPolyCSG) (on github / a fork on github)
• OpenCASCADE (see also OCE, PythonOCC, Cadmium, CADQuery )
• CSGTool
• csg.js
• csgjs-cpp
• ThreeCSG
• Babylon.js CSG
• CSG-BSP

Related software and other resources

• http://www.plasm.net

Outline

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.

Expected Outcome

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:

• BCF-XML current version 2.1 spec (do not use test cases from here - they are broken): https://github.com/BuildingSMART/BCF-XML
• BCF-XML version 3.0 spec and test cases (test cases are for v2.1 and v3.0): https://github.com/BuildingSMART/BCF-XML/tree/release_3_0
• BCF-API version 3.0 spec: https://github.com/BuildingSMART/BCF-API/tree/release_3_0

Test existing server details will be provided.

Future Possibilities

Integration into Blender or FreeCAD

Skills

• Python knowledge
• Knowledge about how to connect to APIs, including how a REST API works
• (Optional) basic Blender or FreeCAD experience

Difficulty

Easy

Additional Information

• Potential mentor(s): Dion Moult
• Organization website: https://ifcopenshell.org
• Communication channels: https://community.osarch.org , ##architect on Freenode , and https://github.com/IfcOpenShell/IfcOpenShell/issues

Outline

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.

Details

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:

• Context sensitive help
• Simple changing of values / numbers via mouse
• Better integration with the parser (error reporting, jump to definitions, ...)

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.

Expected Outcome

• Improved text editing experience for OpenSCAD users

Project Properties

Skills

• Programming language is C++
• GUI programming with the Qt framework

Difficulty

Medium

Additional Information

Mentors: Marius Kintel (IRC: kintel), Torsten Paul (IRC: teepee)

Links:

• Prototype for Autocomplete/Call-Tips openscad/openscad#905
• Patches for Abbreviations feature http://forum.openscad.org/Abbreviations-td17583.html

Outline

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.

Details

• The current font list is implemented as dialog, this should be changed to a dockable window similar to the console
• Preview area should allow the user to enter some (limited) text which is then rendered in either a selectable size or maybe in multiple sizes
• Allow font selection by character, this will allow the user to find fonts that support specific unicode codepoints (e.g. for emoji)
• Select by font name + drag & drop to the editor - keep the feature of the existing font dialog

Expected Outcome

The font selection dialog is replaced with a dockable font selection window with extra functionality.

Project Properties

Skills

• Programming language is C++
• GUI programming with the Qt framework

Difficulty

Medium

Additional Information

• Potential mentor(s): Marius Kintel (IRC: kintel), Torsten Paul (IRC: teepee)
• Organization website: https://www,openscad.org/

Outline

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.

Details

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

• Research options of usable libraries
• Investigate what type of STEP files are accepted as input by various tools
• Select library and integrate into OpenSCAD
• Implement base functionality to export single meshes
• Add test cases to verify the new export functionality
• Update build system to include the new library into installers
• Prototype how more advanced models can be exported

Expected Outcome

• OpenSCAD supports exporting single meshes as STEP
• (optional) Understanding/Plan of how to support additional features supported by STEP

Project Properties

Skills

• Programming language is C++
• Understand and use APIs from external libraries
• Integrate new libraries into the build system for the 3 supported platforms
• Add test cases with files using the new features to allow regression testing

Difficulty

Hard

Size

Long (350h)

Additional Information

• Potential mentor(s): Marius Kintel (IRC: kintel), Torsten Paul (IRC: teepee)
• Organization website: https://www.openscad.org/

Known libraries:

• StepCode - http://stepcode.org/ (https://github.com/stepcode/stepcode)
• OpenCASCADE - https://www.opencascade.com/

Project details

Current scenario

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

Project Properties

Skills

• Programming language Python (Library: PyQt5)
• Knowledge of structural engineer field
• Knowledge of FreeCAD

Difficulty

Medium

Additional Information

• Potential mentor: Amritpal Singh
• This issue on the FreeCAD wiki: https://www.freecadweb.org/wiki/Automate_reinforcement_process
• The GSOC 2019 thread on the FreeCAD forum. Come chat with us there if you're interested! https://forum.freecadweb.org/viewtopic.php?f=8&t=32284

Outline

Allow users to place and move support pillars by clicking in the 3D GUI.

Project Properties

Skills

• C++/Perl

Difficulty

Medium/Hard

Additional information

• slic3r/Slic3r#3062

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.

Outline

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:

• The bundled offline doc is often incomplete, due to the difficulty (and size) to pack it all
• Over a year there are significant differences between the online and offline docs
• Translations are not available offline
• The doxygen-generated docs are in a bad state, hard to read and use and don't explain APIs clearly, and confuse C++ and python
• The wiki is hard to port and back up
• Add-ons documentation is not integrated

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:

• allowing the user to switch between online and offline documentation, and choose between different available languages
• extending and bettering the doxygen-generated documentation, with special care for the python API

• proposing a better Doxygen structure for https://www.freecadweb.org/api/ possibly with interconnection with the wiki

• working on bettering the current wiki (formatting, linking between pages, navigation, etc)
• reimplement the old workbench-defined documentation system, help porting the different addons
• adapt the FreeCAD start page to it
• adapt the FreeCAD help menu (integrate workbenches and addons help entries)
• exploring the different possibilities of git-based documentation, analyzing specially their user-friendliness and ease of edition, and possibilities of maintaining large translations easily and automatically (for ex. connecting with translation platforms) and propose migration workflows

Details

• Get familiar with FreeCAD and the contents of the wiki
• Successfully compile FreeCAD (you'll be working in C++) and the Doxygen docs
• Understand how Doxygen works and specifically how it treats C++ and Python differently
• Work on the FreeCAD C++ source code (modify the whats'this and documentation system, work on the Help menu)
• Work on the in-source code documentation
• Work on the wiki documentation
• Explore and document available open-source documentation systems

Expected Outcome

• A better documentation system inside FreeCAD
• Documentation. Like all open-source projects, it is of uttermost importance to document a lot everything you do. This allows for other people to take on and extend your work more easily.
• Proposals of migration to a better documentation system that would still keep FreeCAD users happy and eager to write and translate

Project Properties

Skills

• Programming language: C++, but understanding some Python will be necessary
• Readiness to work with documentation, reasonably good english writing skills

Difficulty

Medium

Additional Information

• Potential mentors: Yorik
• Link to this page on the FreeCAD wiki: https://www.freecadweb.org/wiki/Upgrade_the_documentation_system
• The GSOC 2019 thread on the FreeCAD forum. Come chat with us there if you're interested! https://forum.freecadweb.org/viewtopic.php?f=8&t=32284

Outline

Utilize cache coherency and parallelization techniques in BRL-CAD's ray tracing pipeline, and demonstrate graphically.

Details

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:

• 2020 OpenCL GPGPU Raytracing
• 2018 Improving Raytracing Performance
• 2017 GPU Boolean Evaluation
• 2016 GPGPU Support for Boolean Evaluation
• 2015 GPU Accelerated Ray Trace Rendering

Expected Outcome

Demonstrate improved ray tracing performance via bundling and OpenCL. Demonstrate performance graphically through a prototype interactive GUI (using OSPRay, O3DE, or Qt).

Project Properties

Skills

• C/C++
• OpenCL
• Intel Threading Building Blocks (TBB) (optional)
• OSPRay (optional)

Difficulty

hard

Additional Information

• Potential mentor(s): Vasco Costa
• Organization website: https://brlcad.org
• Communication channels: https://brlcad.zulipchat.com/

Outline

Create a new importer for files from any EDA software for which there is no built-in importer yet.

Details

A non-exhaustive list of possible EDA software:

• Easy (open source): Fritzing, gEDA, Horizon EDA, LibrePCB, JSchem, pcb-rnd
• Easy, but slightly harder (port existing importer): EasyEDA (link, link), Zuken CR-5000 (link), LTSpice (link)
• Medium (text formats): Allegro ASCII, PADS ASCII, Mentor HyperLynx, SIMetrix, Micro-Cap, ...
• Hard (binary formats): Target 3001!, DipTrace, EAGLE < 5.91, Allegro, Mentor, ...

There are two FOSDEM talks around this topic to get a rough idea of the task:

• Importing into KiCad from CADSTAR
• Reverse-Engineering of (binary) File-Formats

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.

Expected Outcome

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.

Project Properties

Skills

• C++
• Basic knowledge of the EDA software the importer will be for

Difficulty

Depends on the selected EDA package.

Size

175 hours (schematic-only software like LTSpice, SIMetrix, Micro-Cap)
350 hours (software with both schematic and PCB layout)

Additional Information

• Potential mentors:
  • Roberto Fernandez Bautista
  • Thomas Pointhuber
• Organization website: https://kicad.org
• Communication channels:
  • [email protected]
  • Discord channel

Outline

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.

Details

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:

• https://odbplusplus.com/design
• https://gitlab.com/kicad/code/kicad/-/issues/2019

Expected Outcome

An ODB++ exporter that can generate standard ODB++ files using existing v7 KiCad features.

Project Properties

Skills

• C++
• Basic knowledge of EDA software concepts

Difficulty

Medium

Size

350 hours

Additional Information

• Potential mentors:
  • Seth Hillbrand
• Organization website: https://kicad.org
• Communication channels:
  • [email protected]
  • Discord channel

Outline

Develop further the new GUI for BRL-CAD!

Details

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.

Expected Outcome

An improved BRL-CAD GUI.

Project Properties

Skills

• C/C++
• Qt

Difficulty

medium

Size

This project can be scoped medium (175h) or long (350h), depending on the amount of functionality you want to include.

Additional Information

• Potential mentor(s):
  Daniel Rossberg
  Himanshu Sekhar Nayak
  Sean Morrison
• Organization website: https://brlcad.org
• Communication channels: https://brlcad.zulipchat.com

Outline

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.

Details

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.

Expected Outcome

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.

Project Properties

Skills

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.

Difficulty

Medium

Additional Information

• Potential mentor(s): Yorik
• Organization website: https://freecadweb.org
• Communication channels: https://https://forum.freecadweb.org

Outline

appleseed is rendering infrastructure used to make pretty pictures. Make it shoot rays at our native geometry with our ray trace library.

Details

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!

Expected Outcome

A new renderer that utilizes BRL-CAD's LIBRT ray tracing library and appleseed.

Future Possibilities

Integrate with appleseed's GUI or implement features of appleseed's GUI for BRL-CAD.

Project Properties

Skills

• C/C++

Difficulty

medium

Additional Information

• Potential mentor(s): Sean Morrison
• Organization website: https://brlcad.org
• Communication channels: https://brlcad.zulipchat.com

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.

Outline

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.

Details

• Get familiar with how FreeCAD and BRL-CAD work, what are their strengths and limitations, how they differ, how parametric modelling works in both of them
• Successfully compile both applications
• Get familiar with the BRL-CAD API
• Understand how FreeCAD parametric objects (features) are constructed and work, and how the view provider system works. We will basically be constructing FreeCAD view providers around BRL-CAD objects
• Also study the command-line interface tools offered by BRL-CAD, and assess if and how any of these could be put into use
• Implement basic import: Allow to open a BRL-CAD database and display its contents in FreeCAD
• Implement a couple of BRL-CAD-based objects: Or, how to use the FreeCAD modelling tools to produce BRL-CAD objects
• Implement basic saving: How the BRL-CAD-based FreeCAD objects can be saved to a BRL-CAD database, and design a strategy for possible support of other FreeCAD objects

Expected Outcome

• Documentation. Since this is a large task, that might not fit in a single GSOC project, other people (or yourself) will likely work on this project after the GSOC period ends. They must be able to take on the work where it has been stopped. Also, the first steps of this project will involve a lot of research, that should be made as available as possible to others.
• A basic prototype, that allows to open and visualize BRL-CAD databases in FreeCAD, and shows how modelling and saving BRL-CAD objects can work in FreeCAD

Future Possibilities

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.

Project Properties

Skills

• Programming language: C/C++
• Good understanding and use of APIs from FreeCAD and BRL-CAD
• Knowledge of 3D modeling, topology and computational geometry is a plus

Difficulty

High, mostly because you have two different applications to learn and work with

Additional Information

• Potential mentors: Yorik van Havre (FreeCAD), Daniel Rossberg (BRL-CAD)
• Link to this project idea on the FreeCAD wiki: https://www.freecadweb.org/wiki/FreeCAD-BRLCAD_integration
• The GSOC 2019 thread on the FreeCAD forum. Come chat with us there if you're interested! https://forum.freecadweb.org/viewtopic.php?f=8&t=32284

Outline

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.

Details

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

1. write a script that does all the conversion and image downloading

2. write a simple script to just run various existing tools

3. go though the wiki pages of the manual and adjust some of the
   text so it works nicely with some existing tool

4. use a tool or write a script to scrape the HTML representation from Wikibooks

5. 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.

Challenges:

• Investigate current status of available converters
• Optional: Integrate the solution into the OpenSCAD build process

Expected Outcome

• An offline user manual that can be included in OpenSCAD releases.

Project Properties

Skills

• Programming language is python (or some other widely used scripting language... make a suggestion!)

Difficulty

Easy

Additional information

• Script for scraping the WikiPages as HTML by (runsun) - Forum discussion - Github Repository
• Maybe also look at the related Cheat Sheet issue

Mentors: Marius Kintel (IRC: kintel), Torsten Paul (IRC: teepee)

Outline

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.

Details

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:

• Gradients (for hatchs);
• Line pattern support;
• Complex linetype support (with text or shapes)
• ...

Expected Outcome

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.

Project Properties

Skills

• C++
• OpenGL

Difficulty

hard

Additional Information

• Potential mentor(s): Florian
• Organization website: https://librecad.org/
• Communication channels: https://librecad.zulipchat.com/

Outline

Implement the prerequisites for NURBS editing in BRL-CAD's GUIs

Details

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:

• NURBS-Python: https://github.com/orbingol/NURBS-Python
• Blender: https://blender.stackexchange.com/questions/7020/create-nurbs-surface-with-python
• Web3D: https://www.web3d.org/x3d/content/examples/Basic/NURBS/
• 3DSMax/Maya: https://help.autodesk.com/view/3DSMAX/2016/ENU/?guid=__files_GUID_75CD4DE9_8024_4E25_B147_0A0EC8B10031_htm
• Ayam: http://ayam.sourceforge.net/docsdraft/ayam-6.html

Expected Outcome

Implementing the necessary logic for NURBS handling in librt, libbrep, and libged

Future Possibilities

Implementing a visual NURBS editor in a BRL-CAD GUI (mged, Archer, Arbalest)

Project Properties

Skills

• C/C++

Difficulty

medium

Size

long (350h)

Additional Information

• Potential mentor(s): Daniel Rossberg, Sean Morrison
• Organization website: https://brlcad.org
• Communication channels: https://brlcad.zulipchat.com

Outline

Work on the FreeCAD doxygen-generated documentation: Propose a better plan, document the modules better, make it clearer to read, etc.

Details

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.

Expected Outcome

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

Project Properties

Skills

The student should have or build a good knowledge of doxygen, optionally be ready to do some css work too

Difficulty

Medium

Additional Information

• Potential mentor(s): Yorik
• Organization website: https://freecadweb.org
• Communication channels: https://https://forum.freecadweb.org

Outline

Implement the wireframe printing algorithm.

Project Properties

Skills

• C++

Difficulty

Medium

Additional information

• slic3r/Slic3r#2274

Outline

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.

Project Properties

Skills

• C++

Difficulty

Medium

Additional information

• slic3r/Slic3r#2948

Outline

Design a FreeCAD library tool that fetches the content online, without the need to download the whole library

Details

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.

Expected Outcome

A new FreeCAD UI tool

Project Properties

Skills

The student should have a good knowledge of Python or C++, and learn how to build interface tools with Qt/PySide/QtCreator

Difficulty

Medium

Additional Information

• Potential mentor(s): Yorik
• Organization website: https://freecadweb.org
• Communication channels: https://https://forum.freecadweb.org