GSoC/2018/Ideas

< GSoC‎ | 2018
Revision as of 13:41, 10 January 2018 by Boud (Talk | contribs) (Krita)

Jump to: navigation, search
Konqi is giving a lesson!

See also: GSoc Instructions, Last year ideas

Guidelines

Information for Students

These ideas were contributed by our developers and users. They are sometimes vague or incomplete. If you wish to submit a proposal based on these ideas, you may wish to contact the developers and find out more about the particular suggestion you're looking at.

Being accepted as a Google Summer of Code student is quite competitive. Accepted students typically have thoroughly researched the technologies of their proposed project and have been in frequent contact with potential mentors. Simply copying and pasting an idea here will not work. On the other hand, creating a completely new idea without first consulting potential mentors is unlikely to work out.

When writing your proposal or asking for help from the general KDE community don't assume people are familiar with the ideas here. KDE is really big!

If there is no specific contact given you can ask questions on the general KDE development list kde-devel@kde.org. See the KDE mailing lists page for information on available mailing lists and how to subscribe.

Note-box-icon.png
 
Note
These are all proposals! We are open to new ideas you might have!! Do you have an awesome idea you want to work on with KDE but that is not among the ideas below? That's cool. We love that! But please do us a favor: Get in touch with a mentor early on and make sure your project is realistic and within the scope of KDE.

Contents

Adding a Proposal

Note-box-icon.png
 
Note
Follow the template of other proposals!

Project:

If appropriate, screenshot or other image

Brief explanation:

Expected results:

Knowledge Prerequisite:

Mentor:

When adding an idea to this section, please try to include the following data:

  • if the application is not widely known, a description of what it does and where its code lives
  • a brief explanation
  • the expected results
  • pre-requisites for working on your project
  • if applicable, links to more information or discussions
  • mailing list or IRC channel for your application/library/module
  • your name and email address for contact (if you're willing to be a mentor)

If you are not a developer but have a good idea for a proposal, get in contact with relevant developers first.

Ideas

Your Own Idea

Project: Something that you're totally excited about

Brief explanation: Do you have an awesome idea you want to work on with KDE but that is not among the ideas below? That's cool. We love that! But please do us a favor: Get in touch with a mentor early on and make sure your project is realistic and within the scope of KDE. That will spare you and us a lot of frustration.

Expected results: Something you and KDE loves

Knowledge Prerequisite: Probably C++ and Qt but depends on your project

Mentor: Try to see who in KDE is interested in what you want to work on and approach them. If you are unsure you can always ask in #kde-soc on Freenode IRC.

Krita

Krita: digital painting for artists. It support creating images from scratch from begin to end. Krita is a complex application and developers need to have a fair amount of experience in order to be able to do something.

Krita is a widely used digital painting application for professional artists. Last year, Krita gained the ability to create hand-drawn 2D animations, among other new features. For this year, projects that the Krita team would be interested in include the following ideas.

Note that we're always open to ideas you bring in yourself: if you're passionate about something you've come up with yourself, that you want for Krita, that's a big plus for us.

We also expect prospective students to submit at least three patchs for bugs or wishes or small features. We want to know how good you are! See https://phabricator.kde.org/T7724 for some smaller tasks that you could work on that are not bugs.

Project: Implement a Lockfree Hashtable for Krita's Tile Manager

Brief explanation: This is a hard-core project, only suitable for someone with deep knowledge of the problems of designing multi-threaded software. It involves Krita's core datamodel, where the tiles that compose image data are managed. the KisTileHashTable currently uses a QReadWriteLock to manage access to the tiles. This is one of the last bottlenecks when painting and recomposing the image projection. The goal of this project is to remove that lock and replace it with a lockless design. Since this touches the very core of Krita, a thorough test plan is essential.

Expected results: No bottlenecks anymore!

Knowledge Prerequisite: C++, Qt, threads, locks.

Mentor: Dmitry Kazakov (dmkitryK|log on irc)

Project: Extending Animation Support for curves

Brief Explanation: In Krita, you can already add curves that could be applied to some properties of a layer, like opactity, animating those properties. We want the animation support extended by allowing users to place masks (filter masks, transformation masks, transparency masks) on the timeline and animate their properties using curves. Every property of a layer or mask placed on the timeline should be animatable.

Expected results:

  • Implementation of a gui for applying the curve settings to one or more properties of a mask or layer
  • Implementation of the actual rendering of the properties in the frames
  • Saving of these settings

Knowledge Prerequisite:

  • C++ and Qt

Mentor: Boudewijn Rempt (IRC: boud) or Dmitry Kazakov (IRC: dmitryk_log)

Project: Taking the Shape Brush to the next level

Brief Explanation: Krita has a number of interesting brush engines. One of them is the Shape Brush engine. Inspired by Alchemy, the shape brush "throws" shapes on the canvas. The current implementation is limited to geometric shapes. We want the brush engine to be extended to make it possible to load vector shapes defined as PDF or SVG and use those to draw on the canvas as well. Other improvements are the addition of Feathering, an outline mode, edge sharpening and background textures.

Expected Results: A revampted and exciting shapes brush

Knowledge Prerequisite:

  • C++, Qt, Krita

Mentor: Boudewijn Rempt (IRC: boud) or Lukas Tvrdy (IRC: LukasT)

Project: Analysis of thoroughput of Krita Blending Modes and porting them to AVX2

Brief Explanation: Blending modes is the hottest piece of code in Krita. It should process gigabytes of data per second, therefore it should be extremely optimized. Some of its parts are already optimized to use AVX instructions, but some (float16 color spaces) are not. We need to port the rest of the color spaces to AVX and make a research into the possibilities of using AXV2 instructions directly (int16 instructions). It might happen that you will have to extend VC library to get full AVX support. This is another hard-core project only suitable if you have a good deal of experience.

Expected Results: Ported Float16 color spaces to AVX, extended Vc library to support int16 AVX2 instructions and adopted it in Krita

Knowledge Prerequisite: C++, SEE/AVX (read Intel's manual)

Mentor: Dmitry Kazakov (IRC: dmitryk|log)

Project: Partial canvas updates and region of interest (performance optimization for huge (20k+) canvases)

Brief Explanation: We already have an optimization for huge canvases, which is called Instant Preview. But it woks only when the user has the canvas zoomed out to fit the screen. There are some usecases, when the user wants to work with a small "working area" of a huge image and he doesn't care what happens with the rest of the image. This project is targeted to optimize this case.

Expected Results: By the end of the summer we expect these features to be implemented:

  • Partial updates in openGL canvas. Right now we redraw all the image textures in every frame, which is not needed after porting to Qt5.
  • Region of Intereset (ROI) in KisImage. Updates should be reordered and the priority should be given to the areas that are currently visible to the user
  • Work Area Tool. The user is be able to define the area, where he would like to work in. The updates for other parts of the image are skipped until the user exits this special mode.
  • (if there is time) Optimize textures loading to use RIO as well. Theoretically, we can just skip uploading of the tiles that are not visible on the screen at the moment.

Knowledge Prerequisite: C++, OpenGL

Mentor: Dmitry Kazakov (IRC: dmitryk|log), Julian Thijssen (IRC: Nimmy)

Project: Add 3D Painting Assistants

Brief explanation: One of the more innovative features in Krita are the painting assistants. These are shapes overlaid on the canvas that the artist can use to help him achieve perspective, straight lines and other shapes freehand. For complex drawings it would be useful to be able to place 3D models on the canvas, position and scale them and use those as guides for drawing.

Expected results: by the end of the summer, 3D models should be shown on canvas as canvas decorations, using OpenGL in hidden-line wireframe mode. The models should be manipulated using on-canvas controls like other assistants. Magnetic snapping is an optional extra.

Knowledge Prerequisite: C++, Qt, OpenGL, Assimp

Mentor: Julian Thijssen (IRC: Nimmy)

KDE Student Programs

KDE Student Programs is the working group responsible for running Season of KDE and managing KDE's participation in Google Summer of Code, Google Code-In, and other mentorship programmes.

Project: A new Season of KDE Website

Brief explanation: Season of KDE will need a new website to make managing the project easier for us. The core feature set that we're looking to have comprises:

  • Student applications on the website
  • Mentors can mark themselves interested in projects during the application phase
  • Org admins will create slots and assign projects and mentors to slots
  • Manage mid-term evaluations and results
  • Bulk data export and import

For maintainability by the rest of KDE we'd like the app to be in Python (Tornado or a WSGI framework). It would also be nice if the app was an SPA riding on top of a REST API server so we can have command-line tools interacting with the server as well.

Expected results: Easier project administration for KDE.

Knowledge Prerequisite: Python, Tornado/WSGI, LDAP, full-stack web development, Single-Page applications.

Mentor: Boudhayan Gupta <bgupta@kde.org>, BaloneyGeek on IRC

GCompris

Project: finishing started activities

Brief explanation: GCompris is a an educational software suite comprising of numerous activities for children aged 2 to 10. Originally written in Gtk+ it's development team started to rewrite it from scratch in Qt Quick.

Expected results: The aim of this year is to complete and getting merged activities that were started but have not been finished. You can find a list of tasks that you can work on at https://phabricator.kde.org/T7498. First phase is to check what is missing to be integrated (on code and graphic side) and then to complete them. You can find at https://cgit.kde.org/gcompris.git/refs/heads the list of the current branches (some of them need to be dropped, so contact us before starting working on one of them).

Knowledge Prerequisite:

Be interested in children’s education

Be familiar with GCompris concept and content

Basic knowledge in a programming language (a 1 year school course is enough)

Be able to build the Qt Quick version of GCompris

Application guide: Continuing an activity already started or rewriting from scratch is something you have to check before writing your application. Provide a timeline in your application. If you haven't contributed yet please read http://gcompris.net/wiki/An_exercise_for_new_contributors and http://gcompris.net/wiki/Reviewing_an_activity

There are several info in the wiki: http://gcompris.net/wiki/Developer%27s_corner.

Feel free to contact us either on irc or by mail (gcompris-devel@kde.org)

Mentors: Johnny Jazeix (IRC: JohnnyJ), Divyam Madaan (IRC: dmadaan), Rudra Nil Basu (IRC: rudra)

KDE Partition Manager

Project: finishing KAuth support [Season of KDE]

Brief explanation: KDE Partition Manager is a utility program to help you manage the disk devices, partitions and file systems on your computer. It allows you to easily create, copy, move, delete, resize without losing data, backup and restore partitions.

Expected results: Last year a lot of work was done to make KDE Partition Manager not to start as root and use KAuth to elevate privileges. The aim of this project is to finish required refactoring and make sure everything still works.

The two main issues are:

  • SMART support needs to be ported from (unmaitained) libatasmart library to calling smartctl command. This task is likely to be fairly easy.
  • KDE Partition Manager operation runner should be refactored, instead of calling KAuth helper multiple times to run a single command it has to prepare a list of all commands and their inputs and call KAuth helper once. This needs some refactoring in how partition manager reads and writes disk data (e.g. when moving/copying/backing up or restoring partition). In particular we don't want to transfer all the disk data back from the helper to the main application and back to the helper as DBus transport is fairly slow.

Knowledge Prerequisite:

  • Be able to build the KPMcore and KDE Partition Manager from source.
  • Knowledge of C++ / Qt (No knowledge of KDE Frameworks is required).

Application guide: Get in touch on IRC (#kde-devel or #calamares).

Mentors: Andrius Štikonas (IRC:stikonas)

Kopete

Project: Write tests and Improve protocol support

Brief explanation: Kopete is an instant messaging client that has the modular architecture and supports many messaging services with useful plugins to complement them.

Expected results: The aim of this project is to fix the bugs due to porting and improve the frontend and the test coverage.

Knowledge Prerequisite:

  • Be interested in test-driven development.
  • Be familiar with the codebase of KDE in general.
  • Knowledge of C++ / Qt.

Application guide:

Get in touch with us on mailing-list and start hacking KDE and fix bugs. Teams of two people is preferred for this project as it is a lot of work :)

You can contact on IRC also but it is better to discuss over mailing list as not many people are in IRC on #kopete channel.

Mentors: Vijay <vijaykrishnavanshi@gmail.com> (vijay_ on IRC), Kopete Mailing List <kopete-devel@kde.org>

Documentation

Project [for Season of KDE only]: Verify and update the various documentation

Brief explanation: If you have been in and around KDE for some time you might have noticed some changes in the documentation, well here is your chance is to improve them. Documentation can always use some iterations and revisits. Your task is to understand the challenges that a beginner might and write advice for them. Your speed will depend on your familiarity with KDE infrastructure.

Expected results: Better documentation.

Knowledge Prerequisite: C++ and Qt, and good writing skills :)

Mentor: Vijay <vijaykrishnavanshi@gmail.com> (vijay_ on IRC)

LabPlot

LabPlot is a KDE-application for interactive graphing and analysis of scientific data. LabPlot provides an easy way to create, manage and edit plots and to perform data analysis.

Project [for Season of KDE only]: Additional documentation for supported functions and constants

Brief explanation: LabPlot allows the user to generate and plot data based on mathematical expressions parameterizing the data. The internal mathematical parser supports the user with syntax highlighting and text completion. In addition to this there is a dialog where the user can navigate through all supported functions (standard mathematical functions, Bessel functions, Fermi-Dirac functions, zeta functions, etc.) and constants (mathematical constants, constants from astrophysics, nuclear physics, etc.) and select the desired expression. To improve the user experience and to further help the selection of the proper mathematical expression, additional documentation in form of the corresponding article on Wikipedia or on mathworld.com should be provided. The idea is to provide a web view in the dialog where the selection of the supported expressions is done and to load their the corresponding web page providing further information. E.g., by selecting the Gegenbauer polynomials, the user can optionally open the additional documentation showing the wiki page in the local language https://de.wikipedia.org/wiki/Gegenbauer-Polynom (maybe the mobile version) with the option to switch to mathworld docu on http://mathworld.wolfram.com/GegenbauerPolynomial.html.

The task is to systematically go through all supported expressions and to collect the links to the web pages and to implement the optional web view loading those web pages in the dialog mentioned above.

Expected results: Increased user experience during for the input of mathematical expressions

Knowledge Prerequisite: C++, Qt

Mentor: Fabian Kristof - Szabolcs

Project: Plotting of live MQTT data

Brief explanation: LabPlot has already some support for plotting of live-data (http://krajszgsoc.blogspot.de/2017/09/in-finish-line-but-not-in-end.html). To cover more use-cases we want to also support MQTT sources. We need to investigate the available MQTT libraries for Qt:

and to add some support for MQTT to LabPlot.

Expected results: Similar to the currently supported data sources (files, sockets, serial port, SQL databases) we want to support the subscription to MQTT brockers and plotting of their data.

Knowledge Prerequisite: C++, Qt, (optional) knowledge and experience with MQTT

Mentor: Fábián Kristóf - Szabolcs (mailto:fkristofszabolcs@gmail.com)

Project: Import of educational data sets available on the internet

Brief explanation: There are many internet pages providing data sets for educational and study purposes for many different areas (astrophysics, statistics, medicine, etc.). Some tools used in the scientific area provide some "wrappers" for such online sources and allow the user to easily play around with those data sets in the applications whereas the technical details like fetching of data from the server and parsing are done completely transparent for the user. The goal of this project is to add similar functionality to LabPlot. There will be a wizard where the user can select from a thematically grouped list of data sets available online. The internal description of such an online data set should contain the URL with the actual file that needs to be downloaded and the settings for LabPlot's data parser (separator, column names and data types, etc.). The data fetched once should be cached so there is no need to fetch from the web again. Here we can have a look maybe at KStars for how to implement such a caching strategy and maybe even re-use some code from KStars. In addition to the list of pre-defined online sources, we need to elaborate how the user can add new online data sets (together with all the required parametrization) and publish the settings to make them available for everybody.

Expected results: We want to be able to easily import the educational data sets available on the internet.

Knowledge Prerequisite: C++, Qt

Mentor: tbd

Project: Import of data from web-services

Brief explanation: Brief explanation: This goal of this project is to extend the number of supported data sources by adding the possibility to import the data from web services (live and historical financial data, weather, etc.). Most web services expose their data via JSON. We need to add a "JSON filter" to LabPlot capable to connect to a web service, to fetch the data, to parse it and to import into LabPlot's internal data containers. In the GUI the user should be guided through the entry of the service URL, additional services parameters like API token, etc. and through the settings for the actual parsing (which JSON fields to consume and how). Also, it should be possible to refresh the data periodically like it is already possibile for the live data (http://krajszgsoc.blogspot.de/2017/09/in-finish-line-but-not-in-end.html). The goal is also to provide a set of widely known web services so the user can select and import the data from a list of pre-defined services. In addition to this, we need to elaborate the possibility to "publish" the settings for a web-service done by the user and make them publicaly available to every LabPlot user.


Expected results: Similar to the currently supported data sources (files, sockets, serial port, SQL databases) we want to import the data from web services and visualize it.

Knowledge Prerequisite: C++, Qt, (optional) JSON support in Qt

Mentor: tbd

Kdenlive

Kdenlive is a KDE-application for professionnal video editors. It supports hundreds of video formats, and all the features you can expect from a non-linear video editor, including some advanced features like timeline preview rendering, proxy clips and more.

Project [for Season of KDE only]: Improve audio workflow: mixer

Brief explanation: Kdenlive already allows you adjust audio levels for each clip or for an entire track by adding effects. The idea of an audio mixer is to create a new widget that easily allows to control volume and balance for each track without having to search for effects. The core audio components should already be available through our video framework MLT. So this job will require to understand how Kdenlive interacts with MLT. Some details about the audio mixer features can be found in our documentation

Expected results: Better control of the audio output for users

Knowledge Prerequisite: C++, Qt, requires some preliminary studies to understand how Kdenlive/MLT work

Mentor: Jean-Baptiste Mardelle

Project [for Season of KDE only]: Improve on monitor controls for image transformation

Brief explanation: When adding a "Transform" effect to a clip in Kdenlive, you can then resize and move the image directly on the monitor through a Qml overlay. The idea is to also add the possibility to adjust rotation directly on the monitor screen, and improve the general UI of this Qml overlay.

Expected results: Fluent control of size, position and rotation inside the monitor

Knowledge Prerequisite: C++, Qt, Qml - this does not require much knowledge of Kdenlive, and is mostly a Qml work

Mentor: Jean-Baptiste Mardelle

Choqok

Project: Port Choqok to Kirigami

Brief explanation: Current Choqok UI doesn't make use of QML and creates interfaces in C++ files. The idea is to rewrite the interface in QML. At this point is better doing it with Kirigami since this means it will work on Plasma Mobile too.

Expected results: Choqok UI makes use of Kirigami.

Knowledge Prerequisite: C++, Qt, Qml

Mentor: Andrea Scarpino (IRC: ilpianista)

Application guide: Get in touch on IRC (#choqok).

KStars

KStars is free, open source, cross-platform Astronomy Software. It provides an accurate graphical simulation of the night sky, from any location on Earth, at any date and time.

Project: Deep Sky Object Overhaul

Brief explanation: KStars supports many deep sky objects (DSOs) including galaxies, nebulae, supernovae, clusters and more. Currently, some deep sky catalogs are stored in simple space separated text format where they are parsed into KStars directly or into KStars Deep Sky Component SQLite3 database which is then loaded in KStars. However, since all DSOs are loaded at once into memory, this limits the size of catalogs within KStars. A solution similar to how dynamic stars are cached in and out of memory must be developed for DSOs. Furthermore, all catalog entries should have their trixels indexed so that they can be efficiently drawn unto the sky map. Another issue is that catalogs can overlap since there is no cross-identification of various catalogs. For example, Andromeda galaxy exists in Messier catalog as M31, and exists in NGC catalog as NGC 224. The database should support ability to cross-identify objects from all supported and future catalogs.

Expected results:

  • Convert all text-format catalogs to SQLite3 database.
  • Develop master DSO database where cross-identification of objects is supported. Master database can supported addon downloadable catalogs where they can be merged once downloaded by the user.
  • Import of The Principal Galaxy Catalog, 2003 Version (PGC2003) which contains ~1 million galaxies into KStars as a downloadable addon.
  • Caching and drawing optimizations for large catalogs.
  • Cross-identification for all supported DSO catalogs including, but not limited too: NGC/IC/Messier/Arp/PGC/LDN
  • Trixel indexation for all DSOs. Implementation of improved drawing cached routine in KStars for DSOs similar to stars.
  • All necessary updates within KStars maps, tools and dialogs to reflect the above changes.

Knowledge Prerequisite: C++, Qt, Data Structures

Mentor: Jasem Mutlaq (Matrix: Jasem)

Project: Ekos Web Client

Brief explanation: Ekos is KStars premier tool for observatory control and automation. A web client port of Ekos is desired where it communicates with the underlying INDI servers and drivers without a direct dependency on thick desktop clients. Ekos includes many modules including setup, capture, focus, guide, align, and mount. All functionalities of the desktop Ekos client are expected in the web client version using Python+Ajax or similar framework technologies suitable for online dynamic driven clients.

Expected results:

  • Online Ekos web client with all the thick client feature set.
  • Authentication and Registration framework.
  • Support for notifications similar to desktop client.
  • Ajax dynamic driven interface with near real time updates for framing and captures.
  • Multi-user support with granular permissions.
  • Web based INDI Control Panel with all the driver controls as in the desktop version.

Knowledge Prerequisite: C++, Qt, Django/Ajax or similar technology framework.

Mentor: Jasem Mutlaq (Matrix: Jasem)

Project: Implement Qt3D backend for KStars

Brief explanation: The Skymap in KStars desktop version is currently built using QPainter and 2D drawing primitives. In order to take advantage of advances in modern GPU hardware and to present a stunning visual view of the night sky, a 3D backend is desired. Qt 3D provides functionality for near-realtime simulation systems with support for 2D and 3D rendering in both Qt C++ and Qt Quick applications. Within KStars, SkyPainter provides a backend-agnostic class for drawing object unto the skymap regardless of the backend. Previously, an experimental OpenGL backend was developed but was later deprecated due to drawing issues. Since Qt3D provides an abstraction to the backend framework (OpenGL/Vulkan/DirectX), it presents a very flexible framework for building future-proof 3D applications.

Expected results:

  • Create Qt3D based backend to draw all objects currently implemented by QPainter backend.
  • Create realistic colors, shares, textures, meshes, lighting for all stars, solar system, and deep sky objects.
  • Create animations for meteor shows, comet tails, stars twinkle..etc

Knowledge Prerequisite: C++, Qt, Prior experience working with 3D applications/games.

Mentor: Akarsh Simha (Matrix: kstar)


Content is available under Creative Commons License SA 4.0 unless otherwise noted.