GSoC/2012/Ideas: Difference between revisions
| Line 736: | Line 736: | ||
'''Mentor:''' | '''Mentor:''' | ||
Inge Wallin <[email protected]> | Inge Wallin <[email protected]> | ||
==== Project: ==== | |||
'''Brief explanation:''' | |||
'''Expected results:''' | |||
'''Knowledge Prerequisite:''' | |||
'''Mentor:''' | |||
=== Calligra Active === | === Calligra Active === | ||
Revision as of 03:56, 19 February 2012
See also: GSoc Instructions
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 [email protected]. See the KDE mailing lists page for information on available mailing lists and how to subscribe.
Adding a Proposal
Note
Project:
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
How to find ideas? To see previous Project ideas, see: 2011 ideas. Obvious sources of projects are the bugs database, the forum, and your list and IRC channel ideas.
KDE Multimedia
Project: Consistent look and feel
Brief explanation: What we should have is a common, unified appearance of sorts for the kde multimedia apps. Needs to be different from the rest of KDE. Perhaps integrating plasma theming. Dark usually looks good. QML isn't a bad idea either.
Expected results: A consistent look and feel across kdemultimedia apps
Knowledge Prerequisite: Qt, maybe plasma themes, basic UX/UI design
Mentor: Trever Fischer
Amarok
Amarok is a powerful KDE based music player for Linux and Unix, MacOS X and Windows with an intuitive interface. It makes playing the music you love and discovering new music easier than ever before - and it looks good doing it!
Website - Mailing list (for proposal submission) - Google+ page - IRC channel: #amarok on Freenode.
Project:
Brief explanation:
Expected results:
Knowledge Prerequisite:
Mentor:
Project: QMLify Amarok's context view
Brief explanation: Amarok's context view has been rewritten using Plasma for the beginning of the 2.x series. While this technical choice presented and still presents many advantages, the implementation has been lacking on some fronts for various reasons also unrelated to Plasma. The goal of this project is to rewrite and otherwise conceptually revamp the context view, basing it on QML. Specifically, we require a redesigned set of models, and a way to distribute 3rd party context view applets. Optionally, if there's time, a bit of interface work on new context view widgets would also be nice.
Some interesting reading:
Expected results: Amarok's context view, rewritten for QML.
Knowledge Prerequisite: C++ and Qt, QML and SPARQL knowledge a plus.
Mentor: Teo Mrnjavac or another Amarok core team member
Project: Semantic desktop collection in Amarok
Brief explanation: Several years ago a Summer of Code student had developed a Nepomuk collection backend for Amarok. At that time however Nepomuk was a very different beast, and mostly for performance and reliability reasons the work was never used. The goal of this project is to pick either Tracker or Nepomuk (or both!) and develop one or more collection backends for those data stores. The new collection backend should be completely independent from the existing MySQL backend, and should not lack any features compared to the MySQL backend. It should be as decoupled from the UI as possible, and it should reuse the existing collection browser UI and other UI elements rather than writing new ones.
Expected results: At least one fully working collection backend based on Nepomuk or Tracker.
Knowledge Prerequisite: C++ knowledge, Qt recommended, Nepomuk/Tracker/SPARQL knowledge a plus
Mentor: Teo Mrnjavac, maybe also someone from Nepomuk?
Project: Tomahawk features in Amarok
Brief explanation: Tomahawk is a cross platform, open source social media player that allows users to share music seamlessly and listen to it anytime, anywhere. The goal of this project is to implement the same features in Amarok and maintain compatibility with Tomahawk
Expected results: Implement a service in Amarok that allows users to share their music files with online friends and allows them to listen to the tracks via stream
Knowledge Prerequisite: Qt/KDE development(includes C++ and git), streaming
Mentor: Bart Cerneels
Project: Amarok unit testing
Brief explanation: Since recently Amarok has a continuous integration system. This is awesome, but we can hardly exploit its advantages without good unit test coverage. Amarok does have some unit tests, but they are few and mostly out of date. The goal of this project is to assess the current unit testing situation and provide lots and lots of high quality unit tests (and related documentation).
Expected results: Write an agreed-upon number of unit tests that cover speficic Amarok functionality. We expect a list of the exact features/classes the student will write tests for detailed in the project proposal. Functionality in src/core and src/core-impl takes precedence.
Knowledge Prerequisite: C++, Qt and unit testing knowledge a plus
Mentor: Teo Mrnjavac or another Amarok core team member
Project: Spotify Collection
Brief explanation: Spotify is a music streaming service. The goal of this project is to integrate it into Amarok so that Amarok can be used instead of the official Spotify client.
Expected results: Users can log in to Spotify, access their playlists, search for & stream music
Knowledge Prerequisite: C++, Qt
Mentor: Bart Cerneels
digiKam
digiKam is an advanced digital photo management application for Linux, Windows, and Mac-OSX.
Project: Camera User Interface Revamp
Brief explanation: digiKam features a graphical interface to access and download pictures from digital cameras. Code is rather old, using Qt3Support classes for the icon view, the UI code intermangled deeply with backend code, and has not seen very much care and love for some years.
This project would involve taking the old code apart, rewriting a clean code base backend and front-end, but also adding user interface elements to make the most important everyday task as easy as possible.
In more detail: Write a model listing images on a camera (There are two backends, USB mass storage cameras, which are basically files on disk, and GPhoto2 cameras, which require access through a library). Take the existing digikam icon view and delegate classes, which are prepared for code re-use, and put together an icon view for the model. Cleanly separate the code that does the actual work (downloading, converting, renaming) from the UI. Wrap that in the main window.
User Interface design: the current one is powerful, exposing many options. We want to preserve that. But at the same time, there are three very common actions: a) Download all new files to the last used album b) Download all new files to a new album c) Download all new files to an existing album.
It should be possible to carry out task (a) with one click, task (b) and (c) with two or three clicks, without opening a dialog. Friendly to the new user, preserving access to all options for the poweruser.
There also the technical TODO list relevant of this project
Expected results: A camera user interface based on a pure Qt4 model/view and a cleaned code which provides the currently available features, offering a quick path to download new pictures.
Knowledge Prerequisite: Qt, C++. Interest in Qt model/view and User Interface code.
Mentor: Gilles Caulier
Project: Native MacOSX support
Brief explanation:
digiKam needs to be available under MacOSX in native. Currently, - Macports project is the only way to get last digiKam under Apple computers. Macports require to compile all depencies and digiKam as well. It's a long and hazardous solution to see digiKam running under Mac.
Also, current digiKam implementation is not optimized for Mac desktop. A lots of point need to be improved to support better this operating system. Graphical interface need to polished.
See relevant entries in KDE bugzilla about MacOSX support :
Expected results: Provide scripts and configurations to build automatically a DMG archive of digiKam for MacOSX. Improve digiKam GUI everywhere to be more elegant and more optimized for MacOSX.
Knowledge Prerequisite: C++, Qt, MacOSX, scripting, DMG, packaging
Mentor: Gilles Caulier
Project: Video metadata support
Brief explanation:
All recent digital-still camera devices provide video capture. digiKam must be able to manage these files as it do with images. digiKam can already play-back video and register files to the database, but it lack important metadata used to catalog and sort items (as date, camera name, and all record conditions).
To improve video files support, video metadata management done in background need to be improved, to patch Exiv2 shared library, already used by digiKam for photo metadata handling.
See relevant entries in KDE bugzilla about video support :
Expected results: Add video files support to Exiv2. Patch digiKam metadata interface to handle video information.
Knowledge Prerequisite: C++, Qt, video format, metadata
Mentor: Gilles Caulier and Andreas Huggel
Project: Clone Tool for Image Editor
Brief explanation:
In digiKam image editor we need a simple clone tool to be able to remove quickly dusts, spots, and other unwanted artefact from an image.
See relevant entry in KDE bugzilla about it :
Expected results: add a new tool (as new image editor plugin) with the clone feature.
Knowledge Prerequisite: C++, Qt
Mentor: Gilles Caulier or Marcel Wiesweg
Project: Video Slideshow Generator
Brief explanation: In digiKam image editor we need a new tool to export images as video slideshow.
See relevant entry in KDE bugzilla about it :
The tool must be able to export to video files, as MPEG, AVI, DIVX, or to video media, as CD and DVD video.
Expected results: Add a new tool (as new kipi plugin) to export image collections on video. The tool must be able to do authoring with image contents, for example to change order of images, slide time pause, add transition effects, and add main menu for video media. Too, tool must be able to add audio files as a background. The tool must be portable under Linux, MacOSX and Windows.
Knowledge Prerequisite: C++, Qt
Mentor: Gilles Caulier and Angelo Naselli
Project: Face Recognition
Brief explanation: digiKam is already able to detect faces in photos, through libface, OpenCV, and libkface shared libraries, but Face Recognition is not yet properly implemented to identify the person depicted and automatically tag the region on the photo with the person's name.
See relevant entry in KDE bugzilla about it :
Expected results:
- Face Recognition: Improve existing Eigenfaces implementation. Implement Fisherfaces recognition, work with GNU science library to implement the needed QZ algorithm.
- Round up this underlying technology in a libface and libkface library with some test cases.
- optionally, define the format to store tags on regions of images (currently it's only possible to tag an image as a whole) in metadata and database. You will get support here from the digikam core developers.
- Design some user interface solutions for the training tasks involved (telling the classifier what's right and what's wrong)
Knowledge Prerequisite: C++ and Qt. Knowledge of matrices and working with them. Some idea of clustering algorithms and previous OpenCV experience would be useful.
Mentor: Alex Jironkin for face recognition part through libface, Marcel Wiesweg and Gilles Caulier for the digikam integration through libkface interface.
Project: UPnP/DLNA integration
Brief explanation: UPnP is a standard which allows discovery of and access to media contents in a home network. It is supported by many modern TVs and media receivers. With large collections of digital photos presentation on a TV is a natural solution but is not easily possible at the moment.
See relevant entries in KDE bugzilla about :
Expected results: The first step would be to offer digikam's photo collection on the network by providing a UPnP server accessing digikam's database, offering digikam's album structure including all virtual albums, and the files, if necessary, transcoded to the formats specified by DLNA. This will require integration by C++ and on-the-fly provision of contents, and not simply writing a config file for an existing UPnP server application. In the project proposal, we would expect a technical suggestion for the underlying implementation (suggestion: HUPnP, www.herqq.org) with some thought what is already provided by and what is still missing in the chosen low-level library. The second step would be implementation of a control point integrated into digikam which allows to control the presentation of digikam's photos on the TV from within digikam.
To conclude, step 1: photos from digikam are visible on the network and can be browsed from the TV; step 2: someone sitting on the notebook running digikam controls the presentation on the TV
Knowledge Prerequisite:
C++, Qt. Willingness to acquire knowledge of the UPnP specification including some lower-level implementation details.
Mentor:
Marcel Wiesweg
Project: Extending the presentation view QML UI
Brief explanation: Organizing pictures is one thing, at some point you will want to show your pictures to others. For this task, we would like to provide a beautiful UI based on QML which allows fine grained control over the presentation. As the next step, this interface can be used to perform basic operations like assigning tags or ratings, making it an alternative to the current main window for certain tasks.
See relevant entries in KDE bugzilla about :
Expected results: Extend the current basic QML-based presentation view to a full-featured, polished interface for showing pictures, including arranging photos with multiple pictures per screen, storing such presentations for later use. Integrate QML with digikam's library framwork for loading picture files. Work on extending the UI to allow editing of tags, rating, comments etc.
Knowledge Prerequisite:
C++, Qt, QML
Mentor:
Marcel Wiesweg
Project: Auto Noise Reduction
Brief explanation: Improvement Of Noise Reduction tool adjust settings automatically with image contents.
See relevant entry in KDE bugzilla about it :
Expected results: In digiKam, a tool already exist to reduce camera sensor noise, using wavelets algorithm, working on YCrCb color space, and supporting 16 bits color depth images. This tool provide a lots of settings in user interface. In order to speed-up photograph workflow, we need an algorithm able to analyse existing noise type available in image and adjust settings accordingly.
Knowledge Prerequisite: C++, Qt, imagery
Mentor: Gilles Caulier
Project:
Brief explanation:
Expected results:
Knowledge Prerequisite:
Mentor:
Marble
Marble is a Virtual Globe and World Atlas. It runs on Desktop systems (Linux, Windows, Mac) and mobile devices (Nokia N900, N9).
- Project web site
- [email protected] mailing list
- Google+ page
- IRC channel: #marble on Freenode
Project: OpenStreetMap vector rendering with tiling support (draft)
Brief explanation: Marble supports general vector rendering and basic vector rendering for OpenStreetMap. Currently OSM data must be downloaded and opened manually by the user. During this project a tiling scheme (separation of OSM data into small rectangular regions with different zoom levels) should be developed such that Marble can open and display the right part of the map without any further user interaction (other than panning/zooming).
- Develop a tiling scheme that maps lon/lat/zoom tuples to filenames and vice versa
- Use a tool like osmosis to create tiles for a sample region (say, the city you live in)
- Extend Marble's .dgml format to be able to specify .osm files as input (and your tiling scheme)
- Improve the current vector rendering to handle different zoom levels better
- Add more OSM elements for vector rendering in Marble, improve existing ones (e.g. street names)
- (Optional) Work on a .pbf parser for Marble to read .pbf instead of .osm files (much faster)
- (Optional) Look into a new file format tailored for OSM vector rendering for Marble. Research existing formats like mapsforge
- (Optional) Create a tool that automates the process of creating the tiles needed by Marble
Expected results: A new map theme (.dgml) for Marble that is based on locally stored .osm or .pbf files using a (possibly already existing) tiling scheme. The tiles are loaded from a local directory; tile data for a certain region is enough for a start. When opening the map theme in Marble, the locally stored tiles are loaded automatically as needed and displayed by the existing and extended OSM vector rendering.
Knowledge Prerequisite: C++, Qt
Mentor: Torsten Rahn
Project: Marble: Natural Earth Vector Map
Brief explanation: The current "Atlas map" is based on the MWDB2 dataset. The data is pretty old and the whole implementation that covers the Atlas map still has a few traces of "historic" code. There's a new proposal that would introduce the high quality Natural Earth data. This would require several changes to the Marble code and its data. See
http://techbase.kde.org/Projects/Marble/NaturalEarth
Expected results: A full optimized rendering of the Natural Earth map as vector rendering by using and extending Marble's existing classes.
Knowledge Prerequisite: A good grasp over C++ and object-oriented programming, and Qt; writing test cases with Qt; should quickly learn how to write libraries; have a lot of patience; ability to solve software design problems
Mentor: Torsten Rahn <[email protected]>
KDE Edu
Project:
Brief explanation:
Expected results:
Knowledge Prerequisite:
Mentor:
KDevelop
KDE-based Integrated Development Environment, specializing in c++ support, but including a powerful generic framework (definition use chain) which makes it possible to relatively easily support multiple different languages.
Website - Mailing list - IRC channel: #kdevelop on Freenode.
Project:
Brief explanation: To improve first-start impression and general usability, we would like to offer users a Plasma-based dashboard. The dashboard allows to open projects and shows metadata around projects like recent commits, bugs etc. pp.
Expected results: The work by Aleix is continued and finished up giving us a properly integrated Plasma dashboard. The general dashboard allows opening recent files, projects and sessions. It is also possible to create new projects from it. The project dashboard offers notes, rss feeds and maybe other useful features and can be easily customized and shared between developers. Both dashboards adapt their visuals to the color scheme chosen by the user and fit well into KDevelop.
Knowledge Prerequisite: C++/Qt knowledge required, QML/Plasma knowledge would definitely help a lot
Mentor: Aleix and/or Milian
Project:
Brief explanation:
Expected results:
Knowledge Prerequisite:
Mentor:
KDE PIM
KDE PIM is the interest group working on applications related to personal information management, e.g. contacts, calendar, mails, etc.
There are interesting projects on all levels of the software stack: libraries, application porting, new applications, access to online resources, etc.
Have a look at last year's ideas as well.
Website - Project Wiki - Mailing list - IRC channel: #kontact and #akonadi on Freenode.
Project: Improve HTML composing
Brief explanation: The HTML support for the composer is currently limited. This should be improved: Replying and forwarding should (optionally) preserve the HTML format. The composer should use WebKit editing so that all HTML is fully supported. This will extend last years project GSoC/2011/Ideas#Project:_Improved_HTML_support_in_KMail with the composer parts.
Expected results:Replying and forwarding HTML mails should be fully supported. The QTextEdit-based widget in the composer should be replaced by a WebKit-based widget, to support all HTML instead of a small subset. Currently support exists only in the libraries and not in the composer.
Knowledge Prerequisite: C++, Qt, JavaScript and (X)HTML
Mentor: Torgny Nyblom
Project: Plasma Workspace Integration for Akonadi
Brief explanation: Akonadi is intended to offer PIM services to many applications, i.e. not being just there for KDE PIM apps. While other applications are already using Akonadi for data, currently the KDE PIM applications are the main interface for interfacing with the setup or status of the system.
This idea is about working and completing several smaller items for workspace integration
E.g. ways to see the status and progress information of Akonadi infrastructure, similar how status and progress of KIO infrastructure services is made available.
Additional tasks are displaying or allowing creation of data through workspace facilities, e.g. Plasma applets. E.g. KDE currently has multiple notes plasmoids to store user notes. The best looking plasmoid is currently the one that plasma ships, but it does not use akonadi to store notes. It would be better to have one plasmoid which looks awesome and stores data in Akonadi and retiring other plasmoids.
Expected results: Multiple working Plasma Workspace integration bits and pieces as described above
Knowledge Prerequisite: Qt, JavaScript, C++
Mentor: Kevin Krammer, need also a co-mentor from the Plasma team
Project:
Brief explanation:
Expected results:
Knowledge Prerequisite:
Mentor:
Calligra Karbon
Karbon is a vector drawing application with an user interface that is easy to use, highly customizable and extensible.
Web - Mailinglist - IRC channel: #calligra on Freenode.
Project:
Brief explanation: One of the most fundamental basics of drawing is varying the width of your lines to show shape, form and perspective. Almost every line tapers at either end, and often gets thicker and thinner in different places as needed. For purely technical and histrorical reasons though, every vector program (Illustrator, Inkscape, Karbon etc) make curves all one hard width. This proposal is to create a variable width path shape / tool, much like the path tool, would allow drawing curves, but where each node could have its width set so that the line width changed smoothly from node to node. As Karbon is part of the Calligra suite, this would clearly benefit apps such as Krita, also.
Expected results: variable width path tool is able to change the width of any path node to an arbitary percentage (say 155%) of the stroke width. See http://bugsfiles.kde.org/attachment.cgi?id=56995 for mockup. The shape needs to be able to save and load in svg/odf.
Knowledge Prerequisite: C++, Qt, SVG?
Mentor: Thorsten Zachmann
Calligra Words
Web - Mailinglist - IRC channel: #calligra on Freenode.
Project:
Brief explanation:
Expected results:
Knowledge Prerequisite:
Mentor:
Calligra Krita
Krita is a KDE program for sketching and painting, offering an end–to–end solution for creating digital painting files from scratch by masters.
Mailing-list: https://mail.kde.org/mailman/listinfo/kimageshop/
Project Page: http://www.krita.org/
Irc channel: #krita on irc.freenode.net
Forums: http://forum.kde.org/viewforum.php?f=136.
Wiki: http://community.kde.org/Krita
Project: Perspective Drawing:
Brief explanation:
Krita is a 2D painting tool, but artists often need to give the illusion of depth. Krita has two tools to help the user draw perspective correctly: the perspective grid and the perspective assistant. The latter is more advanced, but needs improvements to become a real star feature. It needs to be expanded by allowing real 3D objects to be important and put into perspective. This means rotation, setting the vanishing point, scaling, and then integration with the paint tools. At the same time, to get into the codebase, the student should implement other missing features in the perspective assistant.
Expected results:
A perspective painting assistant that can use real 3D objects and place them on the canvas, integrate with the perspective system and painting system.
Knowledge Prerequisite:
C++, mathematics, Qt. You need a good level of programming experience to tackle this task.
Mentor:
Boudewijn Rempt
Project: Add an infinite canvas/wraparound mode to Krita
Brief explanation:
Krita is a 2D painting application with a focus on texturing, matte painting and comics drawing. For texturing, we need to expand the Krita image model in two ways: make the canvas infinite, so the user never needs stop painting, and making the canvas wraparound in all directions.
Expected results:
Two new canvas modes, where the canvas is infinite and the image size is dynamically set to the size of the largest layer, and a wraparound mode, where the imagesize is fixed, but the canvas can scroll in all directions infinitely, wrapping around and around.
Knowledge Prerequisite:
C++, Qt. You need a good level of programming experience to tackle this task.
Mentor:
Boudewijn Rempt, usability consultant: Bugsbane.
Project: Painting and Separation of 3D Textures
Brief Explanation: As one of it’s use cases, Krita’s vision statement includes painting textures for 3D. 3D textures are typically comprised of a number of separate black and white, RGB or RGBA images. Thus painting for textures typically requires painting on more than one single layer / channel at a time. For example painting a scratch into a metal surface may require painting black onto the bump channel, another colour on the diffuse channel, and another to the specularity channel (as well as possibly some others such as the displacement channel). All of these are affected simultaneously.
Currently Krita’s painting system is only able to paint onto single layers at a time and brushes have not been designed in such a way as to allow adjusting multiple channels simultaneously as would be needed. This topic would require looking at how Krita’s current painting system could be extended to paint the necessary adjustments to the channels used in 3D rendering, show the textures created in OpenGL and then export those channels for use in 3D applications.
Mentor: Lukáš Tvrdý
Used technologies: C++, Qt
Resources: http://www.krita.org
Project: 3D Material Image Maps
Brief explanation: 3D materials are made up of a bunch of images called image maps. If the user could associate layers as image maps in Krita, and paint on all of them at the same time, artists could paint whole 3D materials - something currently only available in high end 3d apps like zBrush (not even Photoshop / Corel Painter). The trick is that the position of what's painted needs to match on every map/layer, but the colours vary. For example, a scratch on a human characters skin would have a red colour map, a white (=raised) bump map, a light grey (=semi-shiny) specularity map etc, all in the exact same location on the each image map. Traditional methods of trying to create each image from scratch or by manipulating the colour map are very, very slow and painful. A simple version of this could be done as follows:
1. Each layer has a toggle in the layers docker called "texture map" or similar. This is turned off by default. When active, the brush paints on *all* layers that currently have "texture map" active.
2. When picking a colour, a dropdown lets the user pick "Default" or any active texture map layer. "Default" is just the current behaviour. If the user selects a layer in the dropdown, then the selected colour will be applied to that layer when painting on *any* layer.
3. In the file or layer menu is an option "Export texture maps" which saves each texture map layer as an image. The layer name and extension appended automatically to the file name. For example, on a file called character.kra, the layer titled "colour" would be saved as "character-colour.jpg" (or whatever format was selected).
For step 3, a simple, one click / shortcut, method is vital, as artists often have to check their material in their 3d app every few minutes, and wading through saving 10 layers individually, each with manual file naming and confirming file format settings each time is unacceptably slow. For any artist who requires this level of control, they can use Layers menu -> "Save Layer as Image" already in krita.
Allowing artists to paint a single material rather than creating multiple separate image maps by hand, would make Krita formidable for painting 3D textures, and the most advanced open source application for 3D texturing.
Used Technologies: C++, Qt, color theory, mathematics
Mentor: Boudewijn Rempt
Project: Matte painting
Brief explanation:
One of Krita's main use cases is as a professional tool for painting textures and mattes in digital film. Mattes are primarily made of sequences of images generated by a combination of two methods, first by animatable spline based shapes, which currently exists and is being developed in blender, and then after that, by hand painting frames for detailed areas and corrections. The trouble is that no currently maintained FOSS application currently tries to provide the ability to create hand painted mattes. This project is to extend Krita for this purpose.
Expected results:
- The ability for Krita to load manually selected sequences of color managed images as frames to be represented as a single layer in Krita. Optionally would be the ability to display playback at reduced resolutions to increase performance and to offset the time at which sequences were inserted.
- A “Timeline” docker which would display the current frame displayed, and allow clicking and dragging to different points in time, updating the image displayed in the canvas to match. Optional would be the ability to zoom and scroll the timeline, mark modified frames on the timeline, playback the image sequence, forwards and backwards as video (most likely only in the openGL mode of Krita or with an external tool like ffplay) and display times in a range of formate EG SMTP, PAL, NTSC, Secam etc.
- Updating the paint and transparency layer types, so that when Krita is using a frame sequence and one of these layer types is created, they also represent a series of frames rather than just a single image. This could possibly be a toggle switch on layers, much as visibility, alpha lock etc. are now.
- The ability to save layers that are displaying frame sequences out as frame sequences also, giving them user definable names (eg where to insert the frame number, how many digits to pad).
- Keyboard shortcuts to move forwards and backwards 1/10/100 frames, to jump to the start and end of the timeline and forward / backwards play if video playback is supported.
Knowledge Prerequisite:
C++, Qt. This is again not a job for a beginning coder.
Mentor: Boudewijn Rempt
Project:
Brief explanation:
Expected results:
Knowledge Prerequisite:
Mentor:
Calligra Stage
Stage is an easy to use yet still flexible KDE-based presentation application.
Mailing-list: https://mail.kde.org/mailman/listinfo/calligra-devel
Project Page: http://www.calligra-suite.org/stage/
Irc channel: #calligra on irc.freenode.net
Forums: http://forum.kde.org/viewforum.php?f=203
Wiki: http://community.kde.org/Calligra/Stage
Project:
Brief explanation:
Expected results:
Knowledge Prerequisite:
Mentor:
Calligra Tables
Tables is a fully-featured calculation and spreadsheet tool. Use it to quickly create and calculate various business-related spreadsheets, such as income and expenditure, employee working hours…
Mailing-list: https://mail.kde.org/mailman/listinfo/calligra-devel
Project Page: http://www.calligra-suite.org/tables/
Irc channel: #calligra on irc.freenode.net
Forums: http://forum.kde.org/viewforum.php?f=203
Wiki: http://community.kde.org/Calligra/Tables
Project: Improve OpenFormula-support
Brief explanation: Calligra Tables supports the OpenFormula-specification to implement formula functions. To fully support all of the defined heighest level 4 we need to add support for following 18 formulas which are missing at the moment in Calligra Tables; averageif, averageifs, b, chisqdist, chisqinv, countifs, critbinom, dde, external, forecast, hyperlink, legacychitest, linest, logest, networkdays, percentrank, prob, sumifs.
Every of those 18 formula should come with unittests to prove that the formula is working as expected. Also every of the formula needs to have documentation so it can be added/edited from within the UI.
Depending on the time we need for that task and if there is time left we would improve the unittest-coverage for all of our formulas.
Sources are at;
- functions the C++ code of the existing set of 564 formula functions supported by Tables currently is within the h+cpp files.
- tests the existing unittests for our functions are within the h+cpp files. Most of the currently supported 564 formula functions comes with unittests.
- docs the documentation for all of our formulas is within the xml files.
Expected results: Full support level 4 of the OpenFormula specification.
Knowledge Prerequisite: Qt/C++
Mentor: Sebastian Sauer <[email protected]>
Calligra Plugins
As Calligra is quite powerful it is easy to add plugins to it that then can be used by all Calligra applications.
Mailing-list: https://mail.kde.org/mailman/listinfo/calligra-devel
Project Page: http://www.calligra-suite.org
Irc channel: #calligra on irc.freenode.net
Forums: http://forum.kde.org/viewforum.php?f=203
Wiki: http://community.kde.org/Calligra
Project: Improve saving of charts to OpenDocument
Brief explanation: The Calligra charting plugin makes it possible to load, display, edit and save charts within Calligra. The charting-plugin can be used in all Calligra applications including Words (the word processor), Tables (the spreadsheet application) and Stage (the presentation application).
While loading and displaying Microsoft Word, Powerpoint and Excel 2000/2003/2007/2010 files and ISO OpenDocument ODT, ODS and ODP files works very well we are rather bad at saving them back. Since the charting-plugin does not only allow viewing but editing and saving this is a rather big problem. In lot of cases charts are basically lost after loading+saving a file. The goal of this project is to fix that and improve the current situation.
Since ISO OpenDocument is the native format of Calligra we would concentrate on improving saving charts to OpenDocument files.
Note that this is a *very* important task for us and has high priority.
Expected results: When a loaded document is saved and loaded again charts are not lost. Ideally a roundtrip does not show any difference before vs after.
Knowledge Prerequisite: Qt/C++
Mentor: Sebastian Sauer <[email protected]>
Project: Improve the Formula Shape
Brief explanation: The Calligra plugin for mathematical formulas makes it possible to load, display, edit and save math formulas within Calligra. The formula plugin can be used in all Calligra applications including Words (the wordprocessor), Tables (the spreadsheet application) and Stage (the presentation application).
The formula shape loads and saves mathematical formulas using MathML, an XML format specially designed for storing mathematics. It also displays the formulas in a nice way and lets the user edit it inline.
However, it is rather simple and the output does not look the way it could do. There are many ways in which this shape can be improved, and to do it all is probably more than a GSoC's amount of work. Here are some examples of ways to improve the formula shape, and the student should pick some of these:
- Add support for so called 'XML entities'. These are inline characters like ε. This is the most important addition.
- Increase the number of special purpose characters supported in a formula (see also entities above).
- Improve the looks of drawn formula components like the square root sign, summary signs or integration signs.
- Improve the support for things like large braces, brackets, matrixes, etc.
- Improve the general layout of formulas, including kerning, fonts and font sizes.
- Improve inline editing of formulas
- (possibly) add support for LateX formulas for people who are used to writing those. This would make it easier for seasoned LateX users to use Calligra Words for writing scientific papers.
- Add support for the OpenOffice.org formula language.
- (slightly off topic) Add support for formula numbering and referencing in the text.
Expected results: An improved formula shape that lets the user include mathematical formulas in a document and is actually useful for real-world scientific papers.
Knowledge Prerequisite: Qt/C++
Mentor: Inge Wallin <[email protected]>
Project:
Brief explanation:
Expected results:
Knowledge Prerequisite:
Mentor:
Calligra Active
Calligra Active is a Calligra interface tailored specifically for use with Plasma/Active on tablet devices.
Mailing-list: https://mail.kde.org/mailman/listinfo/calligra-devel
Irc channel: #calligra on irc.freenode.net
Wiki: http://community.kde.org/Calligra/Active
Project:
Brief explanation:
Expected results:
Knowledge Prerequisite:
Mentor:
KWin
KDE Plasma Compositor and Window manager
Techbase page - Community page - Mailinglist - IRC channel: #kwin on Freenode.
Project: KWin Effect Viewer
Brief explanation: With 4.9 KWin Effects can be written in JavaScript, but there is no convenient way to test the scripts. In this project a viewer application similar to plasmoidviewer should be developed. This could be achieved by using Xephyr and starting a dedicated KWin instance on the embedded X-Server which is just running the effect.
Expected results: Effect Viewer application to test effects including simulation of all possible Windowing events Knowledge Prerequisite: C++/Qt/KDE development
Mentor: Martin Gräßlin
Project: KWin Integration into Plasmate
Brief explanation: With 4.9 KWin became scriptable both through JavaScript and QML. For example window decorations and window switcher can be developed using QML. KWin follows the Plasma package structure for these scriptable elements. For the Plasma Desktop there is Plasmate to easily develop, test and publish packages. This should be extended to develop the various KWin parts.
Expected results: All KWin script types can be developed inside Plasmate
Knowledge Prerequisite: C++/Qt/KDE development - QML/JavaScript knowledge a plus
Mentor: Martin Gräßlin / someone from Plasmate
Nepomuk
Website- Documentation/Howtos - Ontologies - Mailing list - IRC channel: #nepomuk-kde on Freenode.
(Also see the Nepomuk techbase page for a long list of Nepomuk-related ToDos and ideas.)
Project:
Brief explanation:
Expected results:
Knowledge Prerequisite:
Mentor:
Plasma
Website - Mailing list - IRC channel: #plasma on Freenode.
Project: Lazy/Asynchronous Plasmoid Inititalization
Brief explanation: Plasmoids are currently initialized in a synchronous fashion, meaning the construction of a plasmoid is blocking plasma shells (such as Plasma Desktop) at large. This leads to longer startup times than necessary. Instead plasmoids should be lazy initialized, meaning that their creation has little to no impact at all on the instanciating function(s).
Expected results: Plasma Widgets should be initialized in an asynchronous fashion to reduce overall Plasma startup time.
Knowledge Prerequisite: C++/Qt/KDE development
Mentor: Aaron Seigo / Harald Sitter?
Project:
Brief explanation:
Expected results:
Knowledge Prerequisite:
Mentor:
Phonon
Abstraction library for sound and video support. Used by KDE notifications, Amarok, Dragon Player and Qt Software.
Website - Mailing list - IRC channel: #phonon on Freenode.
Project: Implement unit tests
Brief explanation: Phonon does not have any unit tests. They were removed some time ago because they never worked. Any decent library has unit tests.
Expected results:' Phonon gets a comprehensive suite of unit tests.
Knowledge Prerequisites: C++, Qt, unit testing
Mentor: Trever Fischer
Project: Implement encoding capabilities
Brief explanation: Applications could use Phonon to do transcoding, or to save videos from recording devices. Currently Phonon can grab images from webcams for example, but can't do anything useful with them. What needs to be done:
- create an Encoder media node
- define a bunch of common output formats (mjpg, mp4, stuff)
- other useful properties for the Encoder (like output resolution, depth?)
- implement the Encoder in the backends (phonon-vlc, phonon-gstreamer)
- design somewhat similar to AudioDataOutput or VideoDataOutput
- test by transcoding various media
Expected results: Possibility for transcoding media, encoding video from capture sources with Phonon (with the phonon-gstreamer, phonon-vlc backends)
Knowledge Prerequisite: C++, Qt, basic multimedia
Mentor: Trever Fischer
Project:
Brief explanation:
Expected results:
Knowledge Prerequisite:
Mentor:
Solid
Abstraction library for hardware support. Used pretty much anywhere in KDE where there needs to be hardware interaction.
Website - Mailing list - IRC channel: #solid on Freenode.
Project: Easy partitioning in Solid/Dolphin
Brief explanation: Extend the Solid library to support basic partition management, using udisks as a backend for low-level operations; develop a partition manager that uses this new interface, taking ispiration from the work already done for the Chakra Linux installer Tribe; integrate it in a Dolphin plugin.
Expected results: From a user's point of view, Dolphin will provide a quick and easy-to-use graphical interface for operating on drives. From a developer's point of view, Solid will provide a higher level API that will enable programmers to create new disk managers abstracting from the physical details of the hardware they're going to manipulate.
Knowledge Prerequisite: C++/Qt/KDE development, some knowledge about disks and partitions.
Mentor: Dario Freddi <[email protected]>
Project: QML plasmoid for Plasma NetworkManagement
Brief explanation: Create a new shiny plasmoid for Plasma NM using QML technology. The backends will remain in C++, just the user interface will be ported to QML.
Expected results: A new user interface with fluid animations and easy to use. We also expect new dialogs to simplify creating new connections and interacting with existing connections.
Knowledge Prerequisite: C++/Qt/QML/KDE development, some knowledge about network management.
Mentor: Lamarque V. Souza <[email protected]>
Kate
Kate is a powerful programmer's editor.
Website - Mailing list - IRC channel: #kate on Freenode.
Project:
Brief explanation:
Expected results:
Knowledge Prerequisite:
Mentor:
Rekonq
Rekonq is a web browser for KDE based on WebKit. It first focuses on being a light, fast & clean way to access to net. Its development is doubly based on using the new amazing features offered by the WebKit rendering engine and on the rock solid network KDE technologies.
Project:
Brief explanation:
Expected results:
Knowledge Prerequisite:
Mentor:
ownCloud
An open personal cloud which runs on your personal server. It enables accessing your data from all of your devices. Sharing with other people is also possible. It support automatic backups, versioning and encryption.
Website - Mailing list - IRC channel: #owncloud on Freenode.
Project:
Brief explanation:
Expected results:
Knowledge Prerequisite:
Mentor:
KDE Usability
Project: Usability Survey Framework
Brief explanation: Continue work on the Usability Survey Framework from GSoC 2011. The USF allows designers and developers to create small user feedback studies tailored to their application. A service component allows developers to create services to listen for activity on features within their applications (such as a click on a new button) and launch a survey tailored to collecting feedback about that feature. A survey component allows developers and designers to create custom feedback surveys to collect information from the user after they experience the features being studied in the application.
Expected results: The student will work with a Technical Mentor from a KDE project (e.g. Calligra) and develop one or more USF services to help test features within the application. The student will work with a Design Mentor to develop a user feedback survey for the USF service. The student will run a small study using the USF service and survey they created.
Knowledge Prerequisite: Knowledge of C++, XML, and JavaScript a must. Previous experience with KDE application development and/or services is not required but will be very helpful to the student.
Mentor: Technical Mentor: Matt Rogers, project-specific developers? Design Mentor: Celeste Lyn Paul, others?
KDE SDK
Project:
Brief explanation:
Expected results:
Knowledge Prerequisite:
Mentor:
Okular
Project:
Brief explanation:
Expected results:
Knowledge Prerequisite:
Mentor:
Gluon
Gluon is a Free and Open Source framework for creating and distributing games - supporting the flow of the idea all the way from the author to the player of the finished game, and back.
Contacting the Gluon team (irc, email etc)
Project: Version control integration in Gluon Creator
Brief explanation: Gluon Creator is designed to be usable by people who are not programmers, and as such the version management integration has to be simple. There used to be a sprint last June in Randa, Switzerland where the KDevPlatform and Gluon guys sat down together for improving KDevPlatform on to be a usable backend for the Gluon Creator application. There is now a usable backend implementation in KDevPlatform (used for instance in KDevelop) which is powerful and very useful for programmers. This would then be exposed more directly in the user interface in case Gluon Creator, creating a work flow which assists in the use of the version control system.
Expected results:
- Integration of the kdevplatform based version control functionality
- Creating commits as annotated saves
- Revert to earlier commits, with each commit shown in a timeline fashion
- Pulling from and pushing to remote repository
- Addition of easy selection, deletion and creation of branches in the Project dock, as well as merging from other branches
Knowledge Prerequisite: Qt/KDE development (includes C++ & git)
Skill level: medium.
Mentor: Laszlo Papp
Project: Deploy and Integrate Gluon on Mac
Brief explanation: Description: Gluon build has already been tested on Mac a while ago. Unfortunately, we have mostly Linux and Windows developers, thus nobody tested it recently. It would be nice to get Gluon built on Mac OSX with kdelibs underneath. The most challanging part is to get kdelibs built on Mac. It should be a bit simpler then to get the Gluon Creator built with the assistance of the team. It would also be a great addition to have the building steps documented, and creating screenshots. In addition, CMake/CPack support for Mac OS X packaging. Gluon already has NSIS CPack/CMake support for generating a binary for Windows installation. deb and rpm support are also available for generating binaries for Meego and Maemo installations. The concept is already available by the existing cmake/cpack system. The part of task would be to get that concept adopted for Mac and provide a proper package for Mac installation. That would be the missing bit to cover on desktop machines for game players and developers regarding Gluon.
Expected results:
- Successful kdelibs build on Mac
- Properly documented steps how to build kdelibs (FAQ and so forth)
- Successful Gluon build on Mac along with the Gluon Creator
- Documentation how to build Gluon on Mac and some screenshot attracting designers and artists
- Easily deployable packaging system for Mac pulling the dependencies automatically for instance and so on
- Fresh KDE/Gluon/Mac community member with warm welcome :)
Knowledge Prerequisite: Mac OS X and little bit C++
Skill level: medium.
Mentor: Laszlo Papp
Project: Bullet integration into Gluon
Brief explanation: In the summer and fall of 2011, there was a student in Brazil who had some theoritical deal with the task in question, but suddenly disappeared because of some real life issues. We are really greatful for his job, and would like to push it forward on. This project is to take the task on that front, and establish a proper Bullet physics engine integration into the Gluon Engine. On top of that, it would also an invaluable achievement to deal with the exposing in Gluon Creator. It has a lot of potential and as soon as it is in place, game makers could benefit out of it right away. It is a very important task for the Gluon project because the current collision detection is not too advanced for our makers, designers and artists.
Expected results: Expected results:
- New 3D Physics Engine Integration into the Gluon Engine
- Exposed funcitonality to Gluon Creator
- Properly documented code
- etc
Knowledge Prerequisite: C++/Qt development
Skill level: medium.
Mentor: Laszlo Papp and Dan Leinir Turthra Jensen
Project: Unit Testing Framework
Brief explanation: Gluon needs unit tests for quality assurance. While there is a set of unit tests in the Gluon libraries themselves, they are incomplete and only test a fraction of the available capabilities. Extensions and new test classes are needed. As for Gluon Audio for instance, tt will be very important because of a potential backend replacement, but at least extension from a project called "alure" to QtOpenAL, For the smooth transient, it will aid a lot if we can always test the previously working functionalities for regressions. It is also very important from Gluon Smarts point of view because that module was added to Gluon as the result of last GSoC session. It is the newest module requiring test cases to make sure the quality is good enough.
Expected results:
- Finish the tests for Gluon Core
- Finish the tests for Gluon Audio
- Make tests for Gluon Input
- Make tests for Gluon Smarts
- Make tests for Gluon Engine
- Fresh Qt/KDE/Gluon/Test expert, community member with warm welcome :)
Knowledge Prerequisite: C++/Qt development (QtTest)
Skill level: medium.
Mentor: Laszlo Papp
Telepathy
Telepathy is a cross-desktop framework for real-time communication and collaboration - think IM, Voice/Video Conferencing and Collaborative document editing/gaming/etc.
More information:
- Telepathy Framework
- KDE Telepathy
- We can be found on IRC in #kde-telepathy
Project: Message Filtering Plugin System
Brief explanation:
Add support like Kopete/Gmail for various message processing tasks, if the URL contains an image, showing this image, same for for youtube links, translating messages, replacing swear words, and any other idea you can come up with.
Expected results:
Student should create a plugin system, which can load plugins, allows configuring plugins, and has an interface for enabling/disabling these. The student should also make a range of plugins, these should be suggested by the student.
Knowledge Prerequisite:
C++, Qt and KDE libs.
Mentor:
David Edmundson <[email protected]>
Discuss on our mailing list <[email protected]>
Project:
Brief explanation:
Expected results:
Knowledge Prerequisite:
Mentor:
simon
simon is an open source speech recognition system using many parts of the KDE infrastructure. You can find out more about us on our homepage, blog or the development site.
There is also a demonstration video on youtube.
Project:
Brief explanation:
Expected results:
Knowledge Prerequisite:
Mentor:
KDE on Windows
The KDE on Windows subproject makes KDE applications available on Microsoft Windows, both desktop (XP, Vista, 7) and Windows CE
Project:
Brief explanation:
Expected results:
Knowledge Prerequisite:
Mentor:
KDE Accessibility
The KDE Accessibility subproject aims to make KDE applications accessible for all.
See also Getinvolved/accessibility
Project: Focus tracking in KWin and KMagnifier
Brief explanation: Currently the KWin zoom plugin and KMagnifier implement focus tracking using KAccessible. KAccessible uses QAccessible direct to implement focus-tracking. The problem with that is that it only works for Qt/KDE applications. The plan is to change the existing code in the KWin zoom-plugin and KMagnifier to not use KAccessible any longer to fetch the information what application/widget/etc has the focus but to use dbus to connect with AT-SPI2 and fetch all needed informations (means the x/y-coordinates where the focus is atm) from there.
Once done and if we do not lose to much time with unexpected problems there should be enough time left to look at common applications like KWrite, Kate, Konsole, Dolphin, etc. to identify and fix cases where the applications are not sending the proper QAccessible::Focus events so that focus-tracking doesn't work there. See for example the fix I did back then to enable focus-tracking in KWrite/Kate - note that all Qt-widgets and most KDE-widgets are already fine and accessible but that a custom canvas like KWrite/Kate are using them to draw the text are basically not accessible at all what is why the patch introduces new classes to make the canvas accessible including making focus-tracking working.
Plan: I would suggest to setup atspi2+qtatspi and try if Orca/Accerciser are working ( http://community.kde.org/Accessibility/qt-atspi ). atspi2 provides a dbus-service (qdbusviewer) and what we would try to begin with is to write some small qt/kde test-application that connects with that dbus-service and provides us the information when the focus changed. What we need is something like
QDBusConnection::sessionBus().connect("org.kde.kaccessibleapp", "/Adaptor", "org.kde.kaccessibleapp.Adaptor", "focusChanged", this, SLOT(focusChanged(int,int)));
means an signal/event to connect with and that is emitted if the focus changed and the x/y screen-coordinates where the focus is now. Once we have such a test-application a big part of the work we would do within the gsoc is done. Adapting kmag and kwin comes after that.
Links:
- http://blogs.kde.org/node/4287 describes our current solution for focus-tracking
- http://community.kde.org/Accessibility/qt-atspi describes how to setup your environment to get ATSPI2 and Qt working together using the Qt-ATSPI bridge.
- See the linked source-code above and grep there for "focusChanged"
Expected results:
- The KWin zoom-plugin and KMagnifier are using ATSPI2 rather then KAccessible to implement focus-tracking.
- Focus-tracking within KDE works for Qt/KDE applications like it does today with KAccessible (or even better :-) ) and applications using other Toolkits (e.g. GEdit, Firefox and LibreOffice.org) will work too.
Knowledge Prerequisite: C++/Qt
Mentor: Sebastian Sauer <[email protected]>
Project: Screen reader friendly KDE applications
Brief explanation: With Qt at-spi we now have a solution to make KDE applications work with the Orca screen reader from Gnome.
This project is about reaching out to screen reader users in order to find out how to make KDE applications work better with the screen reader. Along with the research is always the writing of patches to implement the findings. This requires good communication skills and some C++ knowledge.
See also:
- http://userbase.kde.org/Accessibility
- http://techbase.kde.org/Development/Tutorials/Accessibility/Screen_Reader_Setup
Expected results:
- Improved experience for users that use a screen reader
- Many small patches in order to emit the right signals to the accessibility framework
- Implementation of QAccessibleInterfaces for custom widgets used in KDE
Knowledge Prerequisite:
- C++/Qt
- Python is a bonus as it will make understanding Orca easier
- Reading code - you will look at code from many different applications and try to fix small issues there
- Build applications, kdelibs and Qt
Mentor: Frederik Gladhorn <[email protected]>
Project: Plasma Accessibility
Brief explanation: Making it possible to use Plasma with a screen reader is the goal of this project. You will have to dive into Plasma in both KDE libs and the desktop shell. It will be necessary to make sure keyboard navigation works and feedback from individual parts of the desktop is good so that the screen reader can make sense of it. This might include working on the screen reader to improve the experience.
See also:
- http://userbase.kde.org/Accessibility
- http://techbase.kde.org/Development/Tutorials/Accessibility/Screen_Reader_Setup
Expected results:
- A Plasma desktop that is usable for people that rely on a screen reader
- Implementation of QAccessibleInterface where it makes sense
- Accessible plasma widgets (krunner, application launcher, systray, panel etc)
Knowledge Prerequisite:
- C++/Qt
- Python is a bonus as it will make understanding Orca easier
- Build Plasma and run it with custom built kdelibs and Qt
Mentor: Frederik Gladhorn <[email protected]>
KStars
KStars is a Desktop Planetarium for KDE. It provides an accurate graphical simulation of the night sky, from any location on Earth, at any date and time. The display includes upto 100 million stars, 13,000 deep-sky objects,all 8 planets, the Sun and Moon, and thousands of comets and asteroids.
Project: Autoguiding in KStars
Brief explanation: Guiding is process by which a star field is kept stationairy within the field of view of a telescope when performing long exposure astronomical imaging. The telescope mount must keep tracking the selected celestial object during the imaging process as it transit the sky. Due to imperfections in the mechanics of the mount and periodic errors, the star field may drift with time. If the drift is not corrected, the resulting image may contain star trails among other deformities. The guiding process depends on selecting a reference star in the frame and correcting the telescope motion by detecting drifts in the telescope axes, and issuing correction commands accordingly. KStars supports INDI which can operate and control numerous astronomical devices. The goal of the project is to add autoguiding support to KStars Ekos tool. Ekos is a tool to aid amateur astronomers in astrophotography. It enables focusing, guiding, and capture of astronomical images using INDI. It is prefereable, but not necessary, to have an actual telescope and a CCD camera. Students may use the INDI telescope and CCD simulators to develop and test autoguiding as well.
Expected results: Ability to automatically guide a mount using a CCD and a telescope for long exposures.
Knowledge Prerequisite:
- C++, Qt.
- Basic knowledge in INDI is required.
- Some knowledge in astronomy is preferable.
Mentor: Jasem Mutlaq
Open Collaboration Services
Aim of the Open Collaboration Services API (OCS API) is the integration of web communities and web based services into desktop and mobile applications. It's free, open, scalable, secure, privacy protected and vendor independent. It was designed by openDesktop.org and was defined as an independent standard by freedesktop.org. It is an open and vendor independent modern REST based API
Project: Extend attica (OCS client lib) with JSON interface support of the Standard
Brief explanation: There has just been a very fresh discussion on the OCS mailing list about standardizing the JSON output. We came to the conclusion, as you can read in that thread, we definitely support it, but there is a demand for reference implementations. Attica has already been existing for a while having XML output support. The task would be to extend attica and the KDE support of that in kde-runtime to support the JSON bits of the Standard. It would be a great addition for GamingFreedom, OpenDesktop.org, Apps4Meego, Plasma, Get Hot New Stuff and so forth.
Expected results:
- Integration of the JSON parser into the attica client library code
- Extend the functionality of the KDE runtime attica operation used by plasma, GHNS and so forth
- Properly documented code
- Unit testing framework extension
- Feedback about the attica codebase in general, and also about the standard
Knowledge Prerequisite: C++/Qt development
Skill level: medium.
Mentor: Laszlo Papp