May 31, 2016

സിപിഎം സൈബർ പോരാളികൾ പല ‘ഫോട്ടോഷോപ്പ്’ റെക്കോർഡും തിരുത്തി കുറിക്കാൻ സാധ്യത കാണുന്നു.
ഡെറ്റ അത്ര കൃത്യമാണൊ എന്നറിയില്ല. എന്നാലും കണ്ടിരിക്കാൻ കൊള്ളാം. 3000 വർഷത്തെ പൈതൃകമുള്ള ഇന്ത്യാ മഹാരാജ്യം ഇത് വരെ ഭൂമി പിടിച്ചടക്കാനായി അങ്ങോട്ട് ചെന്ന് യുദ്ധം ചെയ്തിട്ടില്ല – അത് ഇന്ത്യയുടെ മാത്രം പേരിലുള്ള ലിംക്കാ ബുക്ക് ഓഫ് വൽഡ് റെക്കോഡ് ആണ് എന്നൊക്കെ പഠിപ്പിച്ച സർക്കാർ ഹിസ്റ്റൊറി പുസ്തകത്തിനോടുള്ള നന്ദി ഈ അവസരത്തിൽ പ്രകടിപ്പിക്കുന്നു. #മൈ

Today the Krita team releases Krita 3.0, the Animation Release. Wrapping up a year of work, this is a really big release: animation support integrated into Krita’s core, Instant Preview for better performance painting and drawing with big brushes on big canvases, ported to the latest version of the Qt platform and too many bigger and smaller new features and improvements to mention!

Many of the new features were funded by the 2015 Kickstarter campaign. A big thank-you to all our backers! The remaining stretch goals will be released with Krita 3.1, later this year. And don’t forget that we’ve still got seven days in the current kickstarter campaign, We’re nearly funded, so there should still be time to reach some stretch goals this year, too!

The full list of improvements is too long for a release announcement. Please check out the extensive release notes we prepared!

Note: Krita 3.0 load and saves its configuration and resources in a different place than 2.9 so it’s possible to use both versions together without conflicts. Here is a tutorial on migrating resources.

Windows

On Windows, Krita supports Wacom, Huion and Yiynova tablets, as well as the Surface Pro series of tablets. Trust, Bosto, Genius, Peritab and similar tablets are not supported at this moment because we lack testing hardware that allows us to reproduce reported bugs.

The portable zip file builds can be unzipped and run by double-clicking the krita link. If you want to use the installer builds, please uninstall Krita 2.9 first.

For Windows users, Alvin Wong has created a shell extension that allows you to preview krita images in Windows Explorer. You can install it separately, but it is also included in the setup installers.

If your virus scanner or other security software complains please verify the sha1 checksum noted below: if the checksum checks out, the files are safe.

Krita on Windows is tested on Windows 7, Windows 8 and Windows 10.

Linux

For Linux, we offer AppImages that should run on any reasonable recent Linux distribution. For Ubuntu 12.04 and CentOS 6.x you need the appimage that is built without support for OpenMP. We are working on updating the Krita Lime repository: for now, you can use that to install the krita3-testing build. Helio Castro is packaging Krita for Redhat/CentOS/Fedora.

You can download the appimage, make it executable and run it in place. No installation is needed. At this moment, we only have appimages for 64 bits versions of Linux.

OSX

Krita on OSX will be fully supported with version 3.1. Krita 3.0 for OSX is still missing Instant Preview and High Quality Canvas scaling. There are also some issues with rendering the image — these issues follow from Apple’s decision to drop support for the OpenGL 3.0 compatibility profile in their display drivers. We are working to reimplement these features using OpenGL 3.0 Core profile. For now, we recommend disabling OpenGL when using Krita on OSX for production work. Krita for OSX is tested on 10.9 and 10.11 since we do not have access to other versions of OSX.

Source

A source archive is available for distributions wishing to package Krita 3.0. If you’re a curious user, it is recommended to build Krita directly from the git repository instead, so you get all fixes daily fresh. See David Revoy’s guide for an introduction to building Krita. If you build Krita from source and your version of Qt is lower than Qt 5.6.1, it is necessary to also rebuild Qt using the patches in krita/3rdparty/ext_qt.

മമ്മൂട്ടി സിനിമയുടെ പോസ്റ്റർ വന്നതും അതിനൊരു കൊട്ട ട്രോൾ വന്നതും ഒരുമിച്ചായിരുന്നു. വന്നപാടെ കൊറേയെണ്ണം വന്ന് പേജിപ്പൊ പൂട്ടിക്കുമെന്നും ചെവിയിൽ നുള്ളിക്കോളാനും (അമിത്ഷാ ചേച്ചി മോഡൽ) ഡയലോഗ് അടിച്ച് പോയായിരുന്നു. ദേ, ഇപ്പൊ മമ്മുട്ടി തന്നെ അതെടുത്ത് ഷെയർ ചെയ്തിരിക്കുന്നു. ഇനി ഇക്കയെ ആക്കി എന്നും പറഞ്ഞ് മമ്മൂട്ടിയുടെ പേജ് തന്നെ ഫാൻസ് പൂട്ടിക്കുമോ? ആ!

May 30, 2016

This is the fourth and final part of my LGM 2015 lecture. Part one urged to make a clear choice: is the software you’re making is for creative professionals, or not? Part two was all about the rally car and the need for speed. Part three showed the need to support the free and measured working modes of masters.

Today’s topic is how to be good in creative‐pro interaction. We start by revisiting the cars of part two.

party like it’s…

It is no coincidence that I showed you a 1991 family car and a 1991 rally car:

source: netcarshow.com and imgbuddy.com

I did that because our world—that of software for creative pros—is largely stuck in that era. And just like 1991 king‐of‑the‑hill cars (even factory‐mint examples found in a time capsule), this software is no longer competitive.

yes, it’s pants! source: charliepants.com

It is my observation that in this field there is an abundance of opportunities to do better. If one just starts scratching the surface, on a product, workflow, or interaction level, then today’s software simply starts to crumble.

testing, testing, one two

For instance, while doing research for the Metapolator project, I asked some users to show me how they work with the font design tools of today. They showed me the glyph range, the central place to organise their work and get started:

They also showed me the curve editor, where the detailed work on each glyph is done:

Both of them need the whole screen. In a short amount of time I saw a lot of switching between the both of them. I sensed wasted time and broken flows. I also saw tiny, slow handles in the editor. And I thought: this cannot be it.

They also showed me, in another program, designing in context:

I immediately sensed this was a big deal. I saw that they had pushed the envelope—however, not broken through to the other side.

Besides that, I observed that editing was done in outline mode (see the ‘y’, above), but evaluation is of solid black glyphs. Again I sensed broken flows, because of switching between making and evaluating. And I thought: this cannot be it.

Frank sez…

Enough of that; let’s zoom out from my field report, to the big issue at hand. To paraphrase Zappa:

‘How it has always been’ may not be quite dead, but it sure smells funny.

The question is: how did we get to this situation? Let me dig through my experience to find some of the causes.

First of all we can observe that each piece of creative‐pro software is a vertical market product; i.e. it is not used by the general population; only by certain masters. That means we are in armpit of usability territory. Rereading that blog post, I see I was already knee‐deep into this topic: ‘its development is driven by reacting to what users ask for (features!) and fear of changing “like it has always been” through innovation.’

go on, have another cake

The mechanism is clear: users and software makers, living in very different worlds, have a real hard time communicating. Where they manage, they are having the wrong conversation: ‘gimme more features!’ —‘OK, if that makes you happy.’

What is happening today is that users are discussing software made yesterday. They are not able to communicate that their needs are so lousily addressed. Instead, they want some more cherries on top and this cements the position of this outdated software.

Constantly, users are telling software makers, implicitly and explicitly, ‘add plenty of candy, but don’t change a thing.’

bond of pain

A second cause that I want to highlight is that both users and software makers have worked for years to get on the inside and it has been a really painful experience for all of them. This unites them against change.

Thus users have been fighting several frustrating years to get ‘into’ software that was not designed (for them; armpit of usability, remember), but instead made on terms favourable to the software makers.

Software makers spent year after year trying to make something useful. Lacking any form of user research, the whole process has been an exasperating stab‐in‐the‐dark marathon.

Thus a variant of the Stockholm syndrome spooks both parties. They are scarred‐for‐life victims of the general dynamic of the pro‑software industry. But now that they have gotten this far, their instinct is to sustain it.

the point

Two decades of experience shows that there is a way out of this misery; to become competitive (again). There is no incremental way to get there; you’ll have to snap out of it. What is called for is innovation—of your product, workflow, your interaction. A way that unlocks results is:

1. user research
Experienced researchers cut straight past the wants and get the user needs on the table. (Obligatory health & safety notice: market research has nothing to do with user research; it is not even a little bit useful in this context.)
2. design‐driven innovation
When user needs are clear (see point 1), then a designer can tell you any minute of the project—first to last—what part of ‘how it has always been’ is begging to be replaced, and which part is the solid foundation to build upon. Designer careers are built on getting this right, every time.

Skip either point—or doing it only in a superficial, or non-consequential, way—and I’ll guarantee you’ll stay stuck in 1991. Making it happen requires action:

Software‐makers: enthusiastically seek out user researchers and designers and start to sail by them. Stop considering adding features a good thing, stop being a captive of ‘how it has always been’ and trust the accomplished.

picture show

To illustrate all this, let’s look at some of my designs for Metapolator. To be able to solve these problems of contemporary font design tools that I mentioned above, I had to snap out of the old way.

First of all, I pushed designing in context a lot further, by introducing in‑specimen editing:

Every glyph you see above is directly editable, eliminating switching between overview and editing. The size that the glyphs are displayed in can be adjusted any given moment, whatever suits the evaluate/edit balance.

‘OK, that’s great’ you say, ‘but every once in a while one needs a glyph range to do some gardening.’ To address that, I used a handy trick: the glyph range is just another specimen:

Everybody in the Metapolator team thought I was crazy, but I was dead set on eliminating outline mode. I sensed there was chance to do that here, because the focus moves from working at the edge of the glyph—the high‐contrast black–white transition—to the center line within:

Then there was the matter of offering users generous handles that are fast to grab and use. After brainstorming with Simon Egli, the design shown above was born: put them ‘on sticks’ outside, so that they do not impede visual evaluation of the glyph.

pep talk

In closing: to be good in creative‐pro interaction, I encourage you to—

Do not ask how the past can guide you. Ask yourself what you can do to guide your software for creative pros into the 21st century.

May 28, 2016

തൊലിക്കട്ടിഡാ!
കമ്മട്ടിപ്പാടത്തിലെ‌ ടൈറ്റിൽ ക്രഡിറ്റ്സ്‌ ഫോണ്ട് രചനയാണ്. പഴയ ലിപി രചന. കണ്ട്രോളറും മണികണ്ഠനുമൊക്കെ‌ കാണാനെ എന്നാ ചേലാ!

May 27, 2016

You know what they say: Big hands, small horse.

http://ift.tt/1sf5vgJ

Want evenly spaced lines of text like when writing on the lined paper we all used as kids? Should be easy. Turns out with CSS it is not. This post will show why. It is the result of too much time reading specs and making tests as I worked on Inkscape’s multi-line text.

The first thing to understand is that CSS text works by filling line boxes with glyphs and then stacking the boxes, much as is done in printing with movable type.

A line of CSS text is composed of a series of glyphs. It corresponds to a row of movable type where each glyph represents (mostly) a piece of type. The CSS ‘font-size’ property corresponds to the height of the type. A CSS line box contains a line of CSS text plus any leading (extra space) above and below the line.

The lines in the above figure are set tight, without any spacing between the lines. This makes the text hard to read. It is normal in typesetting to add a bit of leading between lines to give the lines a small amount of separation. This can be done with CSS through the ‘line-height’ property. A typical value of the ‘line-height’ property would be ‘1.2’ which means in the simplest terms to make the distance between the baselines of the text be 1.2 times the font size. CSS dictates that the extra space be split, half above the line, half below the line. The following example uses a ‘line-height’ value of 1.5 (to make the figure clearer).

Unlike with physical type faces, lines can be moved closer together than the height of the glyph boxes by using a ‘line-height’ value less than one. Normally you would not want to do this.

When only one font is used (same family and size), the distance between the baselines is consistent and easy to predict. But with multiple fonts it becomes a bit of a challenge. To understand the inner workings of ‘line-height’ we first need to get back to basics.

Glyphs are designed inside an em box. The ‘font-size’ property scales the em box so when rendered the height of the em box matches the font size. For most scripts, the em box is divided into two parts by a baseline. The ascent measures the distance between the baseline and the top of the box while the descent measures the distance between the baseline and the bottom of the box.

The distinction between ‘ascent’ and descent’ is important as the height of the CSS line box is calculated by finding independently the maximum ascent and the maximum descent of all the glyphs in a line of text and then adding the two values. The ratio between ascent and descent is a font design issue and will be different for different font families. Mixing font families may then lead to a line box height greater than that for a single font family.

Keeping the same font family but mixing different sizes can also give results that are a bit unexpected.

So far, we’ve discussed only ‘line-height’ values that are unitless. Both absolute (‘px’, ‘pt’, etc. ) and relative (‘em’, ‘ex’, ‘%’) units are also allowed. The “computed” value of a unitless value is the unitless value while the “computed” value of a value with units is the “absolute” value. The actual value “used” for determining line box height is for a unitless value, the computed value multiplied by the font size, while for the values with units it is the “absolute value” For example, assuming a font size of 24px:

‘line-height:1.5′
computed value: 1.5, used value: 36px;
‘line-height: 36px’
computed and used values: 36px;
‘line-height: 150%’
computed and used values: 36px;
‘line-height: 1.5em’
computed and used values: 36px.

The importance of this is that it is the computed value of ‘line-height’ that is inherited by child elements. This gives different results for values with units compared to those without as seen in the following figure:

The astute observer will notice that in the above example the line box height of the middle line on the right is not 50 pixels as one might naturally expect. It is actually a bit larger. Why? Recall that the line box height is calculated from the maximum ascent and maximum descent of all the glyphs. One small detail was left out. CSS dictates that an imaginary zero width glyph called the “strut” be included in the calculation. This strut represents a glyph in the containing block’s initial font and with the block’s initial font size and line height. This throws everything out of alignment as shown in the figure below.

So how can one keep line boxes on a regular grid? The solution is to rely on the strut! The way to do this is to make sure that the ascents and descents all child elements are smaller than the containing block strut’s ascent and descent values. One can do this most easily by setting ‘line-height’ to zero in child elements.

As one can see, positioning text on a regular grid can be done through a bit of effort. Does it have to be so difficult? There maybe an easier solution on the horizon. The CSS working group is working on a “Line Grid” specification that may make this trivial.

മനോരമ പത്രം പിണറായെ വിടുന്ന ലക്ഷണം കാണുന്നില്ല. ഇഡലി, ലിഫ്റ്റ്, വെട്ട്, കുത്ത്… ദേ ഇപ്പൊ വീട് വരെ എത്തി. ഇനി വനിതയിൽ ഒരു കുടുമ്പ കവർ പേജും കൂടി കഴിഞ്ഞാൽ ലവർ തുടങ്ങും – തിർഞ്ഞ് വെട്ട്! ഫുൾ മാരക പ്ലാനല്ലേയൊ!
മുസ്ലിം ലീഗിനെ കൊണ്ട് ഇത്രയും കാലം ചെയ്യാൻ കഴിയാത്ത / ചെയ്യാതിരുന്ന ഒരു കാര്യം ജയലളിത ചെയ്തിരിക്കുന്നു – ജയലളിതാ മന്ത്രിസഭയിൽ ഒരു മുസ്ലീം വനിതാ മന്ത്രി. തലൈവി കിട്ക്കി!

May 26, 2016

ഗോ സോളൊ. ജഗതി മാസ്!

May 25, 2016

Last year, after DisplayLink released the first version of the supporting tools for their USB3 chipsets, I tried it out on my Dell S2340T.

As I wanted a clean way to test new versions, I took Eric Nothen's RPMs, and updated them along with newer versions, automating the creation of 32- and 64-bit x86 versions.

The RPM contains 3 parts, evdi, a GPLv2 kernel module that creates a virtual display, the LGPL library to access it, and a proprietary service which comes with "firmware" files.

Eric's initial RPMs used the precompiled libevdi.so, and proprietary bits, compiling only the kernel module with dkms when needed. I changed this, compiling the library from the upstream repository, using the minimal amount of pre-compiled binaries.

This package supports quite a few OEM devices, but does not work correctly with Wayland, so you'll need to disable Wayland support in /etc/gdm/custom.conf if you want it to work at the login screen, and without having to restart the displaylink.service systemd service after logging in.

Plugged in via DisplayPort and USB (but I can only see one at a time)

The source for the RPM are on GitHub. Simply clone and run make in the repository to create 32-bit and 64-bit RPMs. The proprietary parts are redistributable, so if somebody wants to host and maintain those RPMs, I'd be glad to pass this on.
ഭൂതമല്ലേ മനോരമയ്ക്കും മാതൃഭൂമിക്കും അറിയൂ… ദാ, വിജയേട്ടന്റെ ഭാവിയുമായി ജന്മഭൂമി പത്രം! പ്രതാപചന്ദ്രന്റെ ഭാഷയിൽ പറഞ്ഞാൽ ‘ഞങ്ങൾക്ക് ഭൂതത്തിൽ മാത്രമല്ല, ഭാവിയിലുമുണ്ടേടാ പിടി!’ #വിജയൻകഥകൾ
എന്നാലും ഇത്രക്ക് വേണ്ടായിരുന്നു.

May 24, 2016

I spent a good chunk of today writing a technical whitepaper titled Introducing the Linux Vendor Firmware Service — I’d really appreciate any comments, either from people who have seen all progress from the start or who don’t know anything about it at all.

Typos, or more general comments are all welcome and once I’ve got something a bit more polished I’ll be sending this to some important suits in a few well known companies. Thanks for any help!

As some of you already know, xdg-app project is dead. The Swedish conspiracy members tell me it’s a good thing and should turn your attention to project Flatpak.

Flatpak aims to solve the painful problem of the Linux distribution — the fact that the OS is intertwined with the applications. It is a pain to decouple the two to be able to

• Keep a particular version of an app around, regardless of OS updates. Or vice versa, be able to run an uptodate application on an older OS.
• Allow application authors distribute binaries they built themselves. Binaries they can support and accept useful bug reports for. Binaries they can keep updated.

But enough of the useful info, you can read all about the project on the new website. Instead, here comes the irrelevant tidbits that I find interesting to share myself. The new website has been built with Middleman, because that’s what I’ve been familiar with and worked for me in other projects.

It’s nice to have a static site that is maintainable and easy to update over time. Using something like Middleman allows to do things like embedding an SVG inside a simple markdown page and animate it with CSS.

=partial "graph.svg"
:css
@keyframes spin {
0% { transform: rotateZ(0deg); }
100% { transform: rotateZ(359deg); }
}
#cog {
animation: spin 6s infinite normal linear forwards;
}


See it in action.

The resulting page has the SVG embedded to allow text copy & pasting and page linking, while keeping the SVG as a separate asset allows easy edits in Inkscape.

What I found really refreshing is seeing so much outside involvement on the website despite ever publicising it. Even during developing the site as my personal project I would get kind pull requests and bug reports on github. Thanks to all the kind souls out there. While not forgetting about future proofing our infrastructure, we should probably not forget the barrier to entry and making use of well established infrastructures like github.

Also, there is no Swedish conspiracy. Oh and Flatpak packages are almost ready to go for Fedora.

നെറ്റിലും പത്രങ്ങളിലും പിണറായ് കഥകളുടെ ബളഹം – മനോരമ വാർത്തകൾ കണ്ടാ തോന്നും ശരിക്കും പിണറായായിരുന്നു ഫിഡൽ കാട്രോ എന്ന്! ഇനി ഒരു അമർ ചിത്ര കഥാ മോഡിൽ കഥാ പുസ്തകവും കൂടിയായൽ കിടിലനായി!

colour manipulation with the colour checker lut module

motivation

for raw photography there exist great presets for nice colour rendition:

• in-camera colour processing such as canon picture styles
• fuji film-emulation-like presets (provia velvia astia classic-chrome)
• pat david's film emulation luts

unfortunately these are eat-it-or-die canned styles or icc lut profiles. you
have to apply them and be happy or tweak them with other tools. but can we
extract meaning from these presets? can we have understandable and tweakable
styles like these?

in a first attempt, i used a non-linear optimiser to control the parameters of
the modules in darktable's processing pipeline and try to match the output of
such styles. while this worked reasonably well for some of pat's film luts, it
failed completely on canon's picture styles. it was very hard to reproduce
generic colour-mapping styles in darktable without parametric blending.

that is, we require a generic colour to colour mapping function. this should be
equally powerful as colour look up tables, but enable us to inspect it and
change small aspects of it (for instance only the way blue tones are treated).

overview

in git master, there is a new module to implement generic colour mappings: the
colour checker lut module (lut: look up table). the following will be a
description how it works internally, how you can use it, and what this is good
for.

in short, it is a colour lut that remains understandable and editable. that is,
it is not a black-box look up table, but you get to see what it actually does
and change the bits that you don't like about it.

the main use cases are precise control over source colour to target colour
mapping, as well as matching in-camera styles that process raws to jpg in a
certain way to achieve a particular look. an example of this are the fuji film
emulation modes. to this end, we will fit a colour checker lut to achieve their
colour rendition, as well as a tone curve to achieve the tonal contrast.

to create the colour lut, it is currently necessary to take a picture of an
it8 target (well, technically we support any similar target, but
didn't try them yet so i won't really comment on it). this gives us a raw
picture with colour values for a few colour patches, as well as a in-camera jpg
reference (in the raw thumbnail..), and measured reference values (what we know
it should look like).

to map all the other colours (that fell in between the patches on the chart) to
meaningful output colours, too, we will need to interpolate this measured
mapping.

theory

we want to express a smooth mapping from input colours $$\mathbf{s}$$ to target
colours $$\mathbf{t}$$, defined by a couple of sample points (which will in our
case be the 288 patches of an it8 chart).

the following is a quick summary of what we implemented and much better
described in JP's siggraph course [0].

radial basis functions are a means of interpolating between sample points
via

$$f(x) = \sum_i c_i\cdot\phi(\| x - s_i\|),$$

with some appropriate kernel $$\phi(r)$$ (we'll get to that later) and a set of
coefficients $$c_i$$ chosen to make the mapping $$f(x)$$ behave like we want it at
and in between the source colour positions $$s_i$$. now to make
sure the function actually passes through the target colours, i.e. $$f(s_i) = t_i$$, we need to solve a linear system. because we want the function to take
on a simple form for simple problems, we also add a polynomial part to it. this
makes sure that black and white profiles turn out to be black and white and
don't oscillate around zero saturation colours wildly. the system is

$$\left(\begin{array}{cc}A &P\\P^t & 0\end{array}\right) \cdot \left(\begin{array}{c}\mathbf{c}\\\mathbf{d}\end{array}\right) = \left(\begin{array}{c}\mathbf{t}\\0\end{array}\right)$$

where

$$A=\left(\begin{array}{ccc} \phi(r_{00})& \phi(r_{10})& \cdots \\ \phi(r_{01})& \phi(r_{11})& \cdots \\ \phi(r_{02})& \phi(r_{12})& \cdots \\ \cdots & & \cdots \end{array}\right),$$

and $$r_{ij} = \| s_i - t_j \|$$ is the distance (CIE 76 $$\Delta$$E,
$$\sqrt{(L_s - L_t)^2 + (a_s - a_t)^2 + (b_s - b_t)^2}$$ ) between
source colour $$s_i$$ and target colour $$t_j$$, in our case

$$P=\left(\begin{array}{cccc} L_{s_0}& a_{s_0}& b_{s_0}& 1\\ L_{s_1}& a_{s_1}& b_{s_1}& 1\\ \cdots \end{array}\right)$$

is the polynomial part, and $$\mathbf{d}$$ are the coefficients to the polynomial
part. these are here so we can for instance easily reproduce $$t = s$$ by setting
$$\mathbf{d} = (1, 1, 1, 0)$$ in the respective row. we will need to solve this
system for the coefficients $$\mathbf{c}=(c_0,c_1,\cdots)^t$$ and $$\mathbf{d}$$.

many options will do the trick and solve the system here. we use singular value
decomposition in our implementation. one advantage is that it is robust against
singular matrices as input (accidentally map the same source colour to
different target colours for instance).

thin plate splines

we didn't yet define the radial basis function kernel. it turns out so-called
thin plate splines have very good behaviour in terms of low oscillation/low curvature
of the resulting function. the associated kernel is

$$\phi(r) = r^2 \log r.$$

note that there is a similar functionality in gimp as a gegl colour mapping
operation (which i believe is using a shepard-interpolation-like scheme).

creating a sparse solution

we will feed this system with 288 patches of an it8 colour chart. that means,
with the added four polynomial coefficients, we have a total of 292
source/target colour pairs to manage here. apart from performance issues when
executing the interpolation, we didn't want that to show up in the gui like
this, so we were looking to reduce this number without introducing large error.

indeed this is possible, and literature provides a nice algorithm to do so, which
is called orthogonal matching pursuit [1].

this algorithm will select the most important hand full of coefficients $$\in \mathbf{c},\mathbf{d}$$, to keep the overall error low. In practice we run it up
to a predefined number of patches ($$24=6\times 4$$ or $$49=7\times 7$$), to make
best use of gui real estate.

the colour checker lut module

gui elements

when you select the module in darkroom mode, it should look something like the
image above (configurations with more than 24 patches are shown in a 7$$\times$$7 grid
instead). by default, it will load the 24 patches of a colour checker classic
and initialise the mapping to identity (no change to the image).

• the grid shows a list of coloured patches. the colours of the patches are
the source points $$\mathbf{s}$$.
• the target colour $$t_i$$ of the selected patch $$i$$ is shown as
offset controlled by sliders in the ui under the grid of patches.
• an outline is drawn around patches that have been altered, i.e. the source
and target colours differ.
• the selected patch is marked with a white square, and the number shows
in the combo box below.

interaction

to interact with the colour mapping, you can change both source and target
colours. the main use case is to change the target colours however, and start
somewhere).

• you can change lightness (L), green-red (a), blue-yellow (b), or saturation
(C) of the target colour via sliders.
• select a patch by left clicking on it, or using the combo box, or using the
colour picker
• to change source colour, select a new colour from your image by using the
colour picker, and shift-left-click on the patch you want to replace.
• to reset a patch, double-click it.
• right-click a patch to delete it.
• shift-left-click on empty space to add a new patch (with the currently
picked colour as source colour).

example use cases

example 1: dodging and burning with the skin tones preset

to process the following image i took of pat in the overground, i started with
the skin tones preset in the colour checker module (right click on nothing in
the gui or click on the icon with the three horizontal lines in the header and
select the preset).

then, i used the colour picker (little icon to the right of the patch# combo
box) to select two skin tones: very bright highlights and dark shadow tones.
the former i dragged the brightness down a bit, the latter i brightened up a
bit via the lightness (L) slider. this is the result:

example 2: skin tones and eyes

in this image, i started with the fuji classic chrome-like style (see below for
picked the iris colour and saturated this tone via the saturation slider.

as a side note, the flash didn't fire in this image (iso 800) so i needed to
stop it up by 2.5ev and the rest is all natural lighting..

use darktable-chart to create a style

as a starting point, i matched a colour checker lut interpolation function to
the in-camera processing of fuji cameras. these have the names of old film and
generally do a good job at creating pleasant colours. this was done using the
darktable-chart utility, by matching raw colours to the jpg output (both in
Lab space in the darktable pipeline).

here is the link to the fuji styles, and how to use them.
i should be doing pat's film emulation presets with this, too, and maybe
styles from other cameras (canon picture styles?). darktable-chart will
output a dtstyle file, with the mapping split into tone curve and colour
checker module. this allows us to tweak the contrast (tone curve) in isolation
from the colours (lut module).

these styles were created with the X100T model, and reportedly they work so/so
with different camera models. the idea is to create a Lab-space mapping which
is well configured for all cameras. but apparently there may be sufficient
differences between the output of different cameras after applying their colour
matrices (after all these matrices are just an approximation of the real camera
to XYZ mapping).

so if you're really after maximum precision, you may have to create the styles
yourself for your camera model. here's how:

step-by-step tutorial to match the in-camera jpg engine

note that this is essentially similar to pascal's colormatch script, but will result in an editable style for darktable instead of a fixed icc lut.

• need an it8 (sorry, could lift that, maybe, similar to what we do for
basecurve fitting)
• shoot the chart with your camera:
• shoot raw + jpg
• avoid glare and shadow and extreme angles, potentially the rims of your
image altogether
• shoot a lot of exposures, try to match L=92 for G00 (or look that up in
• develop the images in darktable:
• lens and vignetting correction needed on both or on neither of raw + jpg
• (i calibrated for vignetting, see lensfun)
• output colour space to Lab (set the secret option in darktablerc:
allow_lab_output=true)
• standard input matrix and camera white balance for the raw, srgb for jpg.
• no gamut clipping, no basecurve, no anything else.
• maybe do perspective correction and crop the chart
• export as float pfm
• darktable-chart
• load the pfm for the raw image and the jpg target in the second tab
• drag the corners to make the mask match the patches in the image
• maybe adjust the security margin using the slider in the top right, to
avoid stray colours being blurred into the patch readout
• you need to select the gray ramp in the combo box (not auto-detected)
• export csv

edit the csv in a text editor and manually add two fixed fake patches HDR00
and HDR01:

name;fuji classic chrome-like
description;fuji classic chrome-like colorchecker
num_gray;24
patch;L_source;a_source;b_source;L_reference;a_reference;b_reference
A01;22.22;13.18;0.61;21.65;17.48;3.62
A02;23.00;24.16;4.18;26.92;32.39;11.96
...
HDR00;100;0;0;100;0;0
HDR01;200;0;0;200;0;0
...


this is to make sure we can process high-dynamic range images and not destroy
the bright spots with the lut. this is needed since the it8 does not deliver
any information out of the reflective gamut and for very bright input. to fix
wide gamut input, it may be needed to enable gamut clipping in the input colour
profile module when applying the resulting style to an image with highly
saturated colours. darktable-chart does that automatically in the style it
writes.

• fix up style description in csv if you want
• run darktable-chart --csv
• outputs a .dtstyle with everything properly switched off, and two modules
on: colour checker + tonecurve in Lab

fitting error

when processing the list of colour pairs into a set of coefficients for the
thin plate spline, the program will output the approximation error, indicated
by average and maximum CIE 76 $\Delta$E for the input patches (the it8 in the
examples here). of course we don't know anything about colours which aren't
represented in the patch. the hope would be that the sampling is dense enough
for all intents and purposes (but nothing is holding us back from using a
target with even more patches).

for the fuji styles, these errors are typically in the range of mean $\Delta E\approx 2$ and max $\Delta E \approx 10$ for 24 patches and a bit less for 49.
unfortunately the error does not decrease very fast in the number of patches
(and will of course drop to zero when using all the patches of the input chart).

provia 24:rank 28/24 avg DE 2.42189 max DE 7.57084
provia 49:rank 53/49 avg DE 1.44376 max DE 5.39751

astia-24:rank 27/24 avg DE 2.12006 max DE 10.0213
astia-49:rank 52/49 avg DE 1.34278 max DE 7.05165

velvia-24:rank 27/24 avg DE 2.87005 max DE 16.7967
velvia-49:rank 53/49 avg DE 1.62934 max DE 6.84697

classic chrome-24:rank 28/24 avg DE 1.99688 max DE 8.76036
classic chrome-49:rank 53/49 avg DE 1.13703 max DE 6.3298

mono-24:rank 27/24 avg DE 0.547846 max DE 3.42563
mono-49:rank 52/49 avg DE 0.339011 max DE 2.08548


future work

it is possible to match the reference values of the it8 instead of a reference
jpg output, to calibrate the camera more precisely than the colour matrix
would.

• there is a button for this in the darktable-chart tool
• needs careful shooting, to match brightness of reference value closely.
• at this point it's not clear to me how white balance should best be handled here.
• need reference reflectances of the it8 (wolf faust ships some for a few illuminants).

another next step we would like to take with this is to match real film footage
(porta etc). both reference and film matching will require some global exposure
calibration though.

references

• [0] Ken Anjyo and J. P. Lewis and Frédéric Pighin, "Scattered data interpolation for computer graphics" in Proceedings of SIGGRAPH 2014 Courses, Article No. 27, 2014. pdf
• [1] J. A. Tropp and A. C. Gilbert, "Signal Recovery From Random Measurements Via Orthogonal Matching Pursuit", in IEEE Transactions on Information Theory, vol. 53, no. 12, pp. 4655-4666, Dec. 2007.

സാൾട്ട്മാംഗോട്രിയുടെ ആദ്യ ക്ലൈന്റ് ഒരു സിനിമ ആയിരുന്നു. ട്രാഫിക്ക്. (ആദ്യത്തേതും അവസാനത്തേയും സിനിമ അതാണ്). അഞ്ച് കൊല്ലത്തിനു ശേഷം ദാ ഇപ്പൊ ആ പേജിൽ ആളുകൾ വന്ന് ലൈക്കടിക്കുന്നു – ഹിന്ദി ട്രാഫിക്കിനെ പറ്റി മെസേജ് അയക്കുന്നു. ;)
പിണറായി ഫാസിസ്റ്റാണ്. പിണറായി പെട്രോൾ വില കൂട്ടി. തോമസ്സ് ഐസക് ഖജനാവ് കാലിയാണെന്നും പറഞ്ഞ് വികനസങ്ങൾ മുടക്കി, ടാക്സ് കൂട്ടി. പിണറായി പോലീസ് അക്രമം കാണിച്ചു. ഇമ്മാതിരി വാർത്തകൾ ഏറെയാണ്. അധികാരം എൽക്കുന്നതിനു മുന്നേ തന്നെ ഇത്രയും കുറ്റം കേട്ടൊരു മുഖ്യനും മന്ത്രിസഭയും വേറേ കാണില്ല. അവർ ഒന്ന് കയറട്ടെ, എന്നിട്ട് പോരേ ഇറക്കൽ!
“എൽഡിഎഫിന്റെ മന്ത്രിസഭ വന്നാലും വിദ്യാഭ്യാസം മുസ്ലീമുകൾടെ കൈയ്യിലായിരിക്കും. മലപ്പുറത്ത് നിന്നും ജയിക്കുന്ന ഏതേങ്കിലും സഖാവ് കോയ ആ സീറ്റ് കൈക്കലാക്കും.” അടിപ്പോളി പ്രവചനം. സി രവീന്ദ്രനാഥിനു അഭിവാദ്യങ്ങൾ.

May 23, 2016

Could you tell us something about yourself?

I’m Neotheta, 23-year-old from Finland and draw colourful pictures with animals, furries and alike. Drawing has been my passion since I was little, I was also interested in digital art early on but had a love&hate relationship with that because computers were not for kids, unstable and tools were pretty awkward back in those days. So I learned drawing mostly with traditional tools first.

Do you paint professionally, as a hobby artist, or both?

Both, I work full-time as an artist right now and hope to continue so!

What genre(s) do you work in?

Is furry a genre? I practice my own styles to draw animals and furries – luckily this is where the most demand for my work is as well. But I’ve also drawn more cartoony & simplified styles for children’s books.

Whose work inspires you most — who are your role models as an artist?

My mom draws really well, she got me drawing! After that it’s been a blender of many inspirations, they tend to change pretty frequently – except I’ve always loved cats! I’m more of a role-maker than a taker, so I often do things differently on purpose – it’s not always a good thing but probably the reason why I’m currently drawing for a living.

How and when did you get to try digital painting for the first time?

6-years-old, I drew a colourful bunny with MS paint at my mom’s workplace (a school) and told her students that this is the future! After that my parents also gave me a drawing tablet but I was somewhat disappointed at the programs intended for digital art at the time – they were all kind of awkward to use. So I gave up digital art for many years and went back to traditional tools. I think I was 15 when I decided to try again seriously.

What makes you choose digital over traditional painting?

I enjoy bright colours, many of those are difficult to produce with traditional colours. Also the ability to print the finished drawing on desired material, such as fabrics – or test what it looks best on and what size. I can also share the same drawing with many people if the outcome is
awesome.

How did you find out about Krita?

I was actually on a sort of mental breakdown because my computer had kicked the bucket and my new setup simply didn’t function together. I had recently experienced how stable and awesome Debian was for PC and I really wanted to give it a try instead of windows. In the middle of the mess and new things someone told me I should try Krita because it sounded like it’d fit my needs – a drawing program for Linux.

I was in total awe because first I was ready to sacrifice not using my old favorite programs just so I could work stable. But then Krita turned out to be better than my previous combination of using Paint tool Sai + Photoshop CS2, it had all the same features I needed in one. Krita on Linux was also SO STABLE and FAST and there was autosaving just in case. I learned to use Krita really quickly (also thanks to the helpful community!) and kept finding new useful tools like a constant stream. It was like a dream come true (still is).

What do you love about Krita?

It’s so stable and fast, I have it on my powerful desktop and old laptop and it functions so nicely on both of them! The community is wonderful. The brush engine is so diverse, interface is customizable, g’mic plugin, line smoothing, perspective assistants… to name a few!

What do you think needs improvement in Krita? Is there anything that really annoys you?

Better text tools and multipage pdf saving would make Krita perfect for comics.

What sets Krita apart from the other tools that you use?

Stability, fast performance, for Linux, well designed for drawing and painting, and lots of features!

If you had to pick one favourite of all your work done in Krita so far, what would it be, and why?

Everything I’ve drawn in the recent years have been on Krita so it’s a difficult pick. My current favorite is a personal drawing of my dragon character in a mystical crystal cavern.

What techniques and brushes did you use in it?

This is my more simple style, first I sketch, then lineart, colour and add textures last. I’ve mostly used Wolthera’s dynamic inking pen, airbrush, gradients and layer effects. A more detailed description and .kra file for inspecting can be found from my site here: https://neotheta.fi/tutorials/wips/crystal/

Where can people see more of your work?

https://neotheta.fi

Anything else you’d like to share?

I recently made a telegram sticker pack with one sticker to spread word about Krita (when people get my pack they get the Krita sticker too). Feel free to add it to yours too or use in another creative way!

Last weekend, ace Krita hacker Dmitry Kazakov attended KomMissia, the annual Russian comics festival. Best quote award goes to the Wacom booth attendants, who install Krita on all their demo machines because “too many people keep asking about it”!

Here’s Dmitry’s report: enjoy!

Last weekend I have attended the Russian annual comic festival “KomMissia”. That is a nice event where a lot of comic writers, painters and publishers meet, share ideas, talk and have a lot of fun together.

My main goal of visiting the event was to find out what people in the comic industry need and what tools they expect to see in a graphics application. One of the goals of our Kickstarter 2016 is to create text tools for the comic artists, so I got a lot of useful information about the process the painters use.

There were a lot of classes by famous comic masters. I got really impressed by the way how Dennis Calero works (although he doesn’t use Krita, I hope “yet”). He uses custom brushes in quite unexpected way to create the hatches on the painting. He paints a single hatch, then creates a brush from it and then just paints a set of hatches to create a shadow and uses ‘[‘ and ‘]’ shortcuts to modify the size of single hatches. Now I really want to implement a shortcut for that in Krita!

I also got in touch with people from Wacom team who had a booth there. They showed a lot of nice and huge Cintiq’s. The funniest thing happened when I asked them if I can install Krita on their devices. They answered that they do already have Krita on most of their demo machines! They say that quite a lot of people asked them about Krita during the previous events, so they decided to install it by default So now, if you happen to see a Wacom booth on an event, you can easily go a test Krita there!

There were also a lot of classes organized by the art-material shops. They let people try various markers, paints and papers. I tried all of them. And now I have a lot of new ideas for new Krita brushes! Hehe…

This is my “masterpiece” done with watercolor markers We can actually implement something like that… The user might paint with usual brushes and then use a special tool for “watering” the canvas. That might be really useful for painters!

And the paintings below are not just “testing strokes with acrylic markers”. It is live illustration of Kubelka-Munk color reflectance theory! The “lemon yellow” pigment is the same on both pictures, but due to the different opacity of its particles it looks absolutely different on different background colors!

So now I’ve got a lot of ideas about what brushes and tools can be implemented in Krita! Just follow us on Twitter and VK and you will be the first to know about new features!

PS:

More photos and paintings (by Nikky Art) from the event

പുലയൻ എന്ന് പറഞ്ഞതിനല്ല, പുലയൻ എന്ന് ജാതി സംബോധന ചെയ്തതാണ് സെൻസർ ബോർഡ് വിലക്കിയതെന്ന് ബോർഡ് അംഗം വിജയകൃഷ്ണൻ. നായരെ നായരെന്ന് വിളിക്കാം, പട്ടരെ പട്ടരെന്നും, പുലയനു ബീപ്പും! രമേഷ് പിശാരടി അവതരിപ്പിക്കുന്ന ബഡായി ബംഗ്ലാവിൽ ‘പണ്ടാരത്തിനു’ ബീപ്പും ‘പിശാരടി’ക്ക് നൊ ബീപ്പും ആണല്ലോ? പിശാരടിയെന്താ ജാതി സംബോധനയല്ലേ?

This is my last post about the gnome-software plugin structure. If you want more, join the mailing list and ask a question. If you’re not sure how something works then I’ve done a poor job on the docs, and I’m happy to explain as much as required.

GNOME Software used to provide a per-process plugin cache, automatically de-duplicating applications and trying to be smarter than the plugins themselves. This involved merging applications created by different plugins and really didn’t work very well. For 3.20 and later we moved to a per-plugin cache which allows the plugin to control getting and adding applications to the cache and invalidating it when it made sense. This seems to work a lot better and is an order of magnitude less complicated. Plugins can trivially be ported to using the cache using something like this:


/* create new object */
id = gs_plugin_flatpak_build_id (inst, xref);
-  app = gs_app_new (id);
+  app = gs_plugin_cache_lookup (plugin, id);
+  if (app == NULL) {
+     app = gs_app_new (id);
+  }


Using the cache has two main benefits for plugins. The first is that we avoid creating duplicate GsApp objects for the same logical thing. This means we can query the installed list, start installing an application, then query it again before the install has finished. The GsApp returned from the second add_installed() request will be the same GObject, and thus all the signals connecting up to the UI will still be correct. This means we don’t have to care about migrating the UI widgets as the object changes and things like progress bars just magically work.

The other benefit is more obvious. If we know the application state from a previous request we don’t have to query a daemon or do another blocking library call to get it. This does of course imply that the plugin is properly invalidating the cache using gs_plugin_cache_invalidate() which it should do whenever a change is detected. Whether a plugin uses the cache for this reason is up to the plugin, but if it does it is up to the plugin to make sure the cache doesn’t get out of sync.

And one last thing: If you’re thinking of building an out-of-tree plugin for production use ask yourself if it actually belongs upstream. Upstream plugins get ported as the API evolves, and I’m already happily carrying Ubuntu and Fedora-specific plugins that either self-disable at runtime or are protected using --enable-foo configure argument.

This is my penultimate post about the gnome-software plugin structure. If you’ve followed everything so far, well done.

There’s a lot of flexibility in the gnome-software plugin structure; a plugin can add custom applications and handle things like search and icon loading in a totally custom way. Most of the time you don’t care about how search is implemented or how icons are going to be loaded, and you can re-use a lot of the existing code in the appstream plugin. To do this you just save an AppStream-format XML file in either /usr/share/app-info/xmls/, /var/cache/app-info/xmls/ or ~/.local/share/app-info/xmls/. GNOME Software will immediately notice any new files, or changes to existing files as it has set up the various inotify watches.

This allows plugins to care a lot less about how applications are going to be shown. For example, the steam plugin downloads and parses the descriptions from a remote service during gs_plugin_refresh(), and also finds the best icon types and downloads them too. Then it exports the data to an AppStream XML file, saving it to your home directory. This allows all the applications to be easily created (and then refined) using something as simple as gs_app_new("steam:foo.desktop"). All the search tokenisation and matching is done automatically, so it makes the plugin much simpler and faster.

The only extra step the steam plugin needs to do is implement the gs_plugin_adopt_app() function. This is called when an application does not have a management plugin set, and allows the plugin to claim the application for itself so it can handle installation, removal and updating. In the case of steam it could check the ID has a prefix of steam: or could check some other plugin-specific metadata using gs_app_get_metadata_item().

Another good example is the fwupd that wants to handle any firmware we’ve discovered in the AppStream XML. This might be shipped by the vendor in a package using Satellite, or downloaded from the LVFS. It wouldn’t be kind to set a management plugin explicitly in case XFCE or KDE want to handle this in a different way. This adoption function in this case is trivial:

void
{
if (gs_app_get_kind (app) == AS_APP_KIND_FIRMWARE)
gs_app_set_management_plugin (app, "fwupd");
}


The next (and last!) blog post I’m going to write is about the per-plugin cache that’s available to plugins to help speed up some operations. In related news, we now have a mailing list, so if you’re interested in this stuff I’d encourage you to join and ask questions there. I also released gnome-software 3.21.2 this morning, so if you want to try all this plugin stuff yourself your distro if probably going to be updating packages soon.

അൻവർ അലി ഞെട്ടിക്കുന്നു. ഗംഭീര വരികൾ. പണ്ട് സ്റ്റീവ് ലോപ്പസിൽ ‘നാം ഈ നഗരകാന്താരമതിൽ വീണുരുകീടുമോ….’ എന്നത് കേട്ട് രോമാഞ്ചിച്ചതാ. അന്ന് അത് മഗ്ര ആക്കനുള്ള കോൺഫിഡൻസ് ഇല്ലായിരുന്നു. ഇതവണയും പകുതി ചെയ്ത് “മ്മള് കൂടിയ കൂടൂലാ” എന്നും പറഞ്ഞ് നിർത്തിയതാണ്, ചാറ്റിൽ വന്ന് ചൊറിഞ്ഞ് മൂപ്പിച്ച അനിവർ മഹാനു നന്ദി.
അൻവർ അലി ഞെട്ടിക്കുന്നു. ഗംഭീര വരികൾ. പണ്ട് സ്റ്റീവ് ലോപ്പസിൽ ‘നാം ഈ നഗരകാന്താരമതിൽ വീണുരുകീടുമോ….’ എന്നത് കേട്ട് രോമാഞ്ചിച്ചതാ. അന്ന് അത് മഗ്ര ആക്കനുള്ള കോൺഫിഡൻസ് ഇല്ലായിരുന്നു. ഇതവണയും പകുതി ചെയ്ത് “മ്മള് കൂടിയ കൂടൂലാ” എന്നും പറഞ്ഞ് നിർത്തിയതാണ്, ചാറ്റിൽ വന്ന് ചൊറിഞ്ഞ് മൂപ്പിച്ച അനിവർ മഹാനു നന്ദി.
നമ്മ ഖസാക്ക് എന്റോസൽഫാൻ വിക്റ്റിംസിനെ സഹായിക്കാണെന്ന് അറിഞ്ഞ സാഹചര്യത്തിൽ അതിനെ പ്രോത്സാഹിപ്പിക്കുകയും സഹായിക്കുകയും ചെയ്തവർക്ക് നന്ദി. അതേ ആവശ്യങ്ങൾക്കായി ഒരു ഫണ്ട് റേസർ ഓടിക്കുന്നു, ആവുന്ന വിധം സഹായിക്കുക.

May 22, 2016

After my last post, I wanted to talk more about the refine functionality in gnome-software. As previous examples have shown it’s very easy to add a new application to the search results, updates list or installed list. Some plugins don’t want to add more applications, but want to modify existing applications to add more information depending on what is required by the UI code. The reason we don’t just add everything at once is that for search-as-you-type to work effectively we need to return results in less than about 50ms and querying some data can take a long time. For example, it might take a few hundred ms to work out the download size for an application when a plugin has to also look at what dependencies are already installed. We only need this information once the user has clicked the search results and when the user is in the details panel, so we can save a ton of time not working out properties that are not useful.

Lets looks at another example.

gboolean
gs_plugin_refine_app (GsPlugin *plugin,
GsApp *app,
GsPluginRefineFlags flags,
GCancellable *cancellable,
GError **error)
{
/* not required */
if ((flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_LICENSE) == 0)
return TRUE;

return TRUE;

/* FIXME, not just hardcoded! */
if (g_strcmp0 (gs_app_get_id (app, "chiron.desktop") == 0))

return TRUE;
}


This is a simple example, but shows what a plugin needs to do. It first checks if the action is required, in this case GS_PLUGIN_REFINE_FLAGS_REQUIRE_LICENSE. This request is more common than you might expect as even the search results shows a non-free label if the license is unspecified or non-free. It then checks if the license is already set, returning with success if so. If not, it checks the application ID and hardcodes a license; in the real world this would be querying a database or parsing an additional config file. As mentioned before, if the license value is freely available without any extra work then it’s best just to set this at the same time as when adding the app with gs_app_list_add(). Think of refine as adding things that cost time to calculate only when really required.

The UI in gnome-software is quite forgiving for missing data, hiding sections or labels as required. Some things are required however, and forgetting to assign an icon or short description will get the application vetoed so that it’s not displayed at all. Helpfully, running gnome-software --verbose on the command line will tell you why an application isn’t shown along with any extra data.

As a last point, a few people have worries that these blogs are perhaps asking for trouble; external plugins have a chequered history in a number of projects and I’m sure gnome-software would be in an even worse position given that the core maintainer team is still so small. Being honest, if we break your external plugin due to an API change in the core you probably should have pushed your changes upstream sooner. There’s a reason you have to build with -DI_KNOW_THE_GNOME_SOFTWARE_API_IS_SUBJECT_TO_CHANGE

Data nerds, here is the data!

Funding Krita

We’re running this kickstarter to fund Krita’s development. That sounds like a truism, but free software projects actually trying to fund development is still a rarity. When KDE, our mother project, holds a fund raiser it’s to collect budget to make developers meetings possible, fund infrastructure (like this, Krita’s website) and so on, but KDE does not pay developers. Other projects don’t even try, or leave it to individual developers. Still others, like Blender, have a lot of experience funding development, of course.

We are happily learning from Blender, and have funded development for years. The first fund raisers were to pay Lukas Tvrdy to work full-time on Krita for a couple of months. His work was handsomely funded and made it possible for Krita to take the leap from slow-and-buggy to usable for day to day work.

Since 2013, the Krita Foundation supports Dmitry Kazakov to work full-time on Krita. And if we may be allowed to toot our horn a bit, that’s a pretty awesome achievement for a project that’s so much smaller than, for example, Blender. The results are there: every release make the previous release look old-hat. Since 2015, the Foundation also sponsors me, that’s Boudewijn Rempt, to work on Krita for three days a week. The other three days I have a day job — Krita doesn’t really bring in enough money to pay for my mortgage yet.

So, what’s coming in, and what’s going out?

In:

• Kickstarter: last year’s kickstarter resulted in about 35,000 euros. (Which explains this year’s goal of 30,000, which I’m sure we’re going to make!)
• Monthly donations through the development fund: about 350 euros per month, 4200 euros per year
• Krita on Steam: about 500 euros a month, 6000 euros per year
• One-time donations through paypal: about 500 euros per month, since this drops of sharply during the kickstarter month, it’s only about 5000 euros a years
• Sales of training videos: about 500 euros per month, same as with the donations, so about 5000 euros a year.

Last year we also had a total of 20,000 euros in special one-time donations, one earmarked for the port to Qt 5.

So, we have a yearly income of about 60.000 euros. Not bad for a free software project without any solid commercial backing! Especially not when looking at what we’re doing with it!

Now for spending the money — always fun!

• Sponsored development: for Dmitry and me together, that’s about 42,000 a year. Yes, we’re cheap. And if you’re a commercial user of Krita and need something developed, contact us!
• Supporting our volunteers: there are some volunteers in our community who spend an inordinate amount of time on Krita, for instance, preparing and sending out all kickstarter rewards. Dutch law allows us to give those volunteers a little something , and that comes to about 3000 euros a year.
• Hardware. We cannot buy all obscure drawing tablets on the market, so that’s not where we spend our money. Besides, manufacturers like Wacom, Huion and Yiynova have supported us by sending us test hardware! But when we decided to make OSX a first-level supported platform, we needed a Mac. When there were reports of big trouble on AMD CPU/GPU hardware, we needed a test system. This comes to about 2500 euros
• Mini-sprints: Basically, getting a small groups, the Summer of Code students, me and Dmitry together to prepare the projects, or gettting Wolthera and me together to prepare the kickstarter. That’s about 1000 euros a year.
• Video course: we spend about 3000 euros a year on creating a new video training course. This year will be all about animation!
• Kickstarter rewards, postage, administrative costs: 7000 euros.

So, the total we spend at the moment is about… 57,500 euros.

In other words, Mr. Micawber would declare us to be happy! “Annual income twenty pounds, annual expenditure nineteen nineteen and six, result happiness. Annual income twenty pounds, annual expenditure twenty pounds ought and six, result misery.

But there’s not much of a buffer here, and a lot of potential for growth! And that’s still my personal goal for Krita: over the coming year or two, double the income and the spending.

കമ്മട്ടിപ്പാടം, സ്പോയലർ അലേർട്ട് (കാണാത്തവർ വായിക്കരുത്, പ്ലീസ്) . . . . . . . . . . . സെക്കന്റ്സ് ഷൊ, കിരീടം/ചെങ്കോൽ പോലെ തന്നെയുള്ള മറ്റൊരു സിനിമയാണ് കമ്മട്ടിപ്പാടം എന്ന അഭിപ്രായത്തൊട് വിയോജിപ്പുണ്ട്. ഡ്രാമ ഭാഗത്ത് ചില സാമ്യം കാണിക്കാമെങ്കിലും അതിൽ നിന്നും മാറി വലിയ കാൻവാസിൽ രാഷ്ട്രീയം പറയുന്ന സിനിമയാണ് കമ്മട്ടിപ്പാടം. തന്റേതല്ലാത്ത കാരാണത്താൽ ചതിപ്പിൽ ‘പെട്ടു പോവുന്ന’ സ്വ്പനങ്ങൾ തകരുന്നവന്റെ കഥയല്ല കമ്മട്ടിപ്പാടം. ഇതിലെ എല്ലാ നായകന്മാരും ജനിക്കുന്നതും […]

Today for Bassel’s 35th Birthday (#happybdaybassel) We Released Along With Many Others, The Cost of Freedom and Waiting… A Prose Book Now Available in Print.

The plugin loader supports a gs_plugin_refresh() vfunc that is called in various situations. To ensure plugins have the minimum required metadata on disk it is called at startup, but with a cache age of infinite. This basically means the plugin must just ensure that any data exists no matter what the age.

Usually once per day, we’ll call gs_plugin_refresh() but with the correct cache age set (typically a little over 24 hours) which allows the plugin to download new metadata or payload files from remote servers. The gs_utils_get_file_age() utility helper can help you work out the cache age of file, or the plugin can handle it some other way.

For the Flatpak plugin we just make sure the AppStream metadata exists at startup, which allows us to show search results in the UI. If the metadata did not exist (e.g. if the user had added a remote using the commandline without gnome-software running) then we would show a loading screen with a progress bar before showing the main UI. On fast connections we should only show that for a couple of seconds, but it’s a good idea to try any avoid that if at all possible in the plugin.
Once per day the gs_plugin_refresh() method is called again, but this time with GS_PLUGIN_REFRESH_FLAGS_PAYLOAD set. This is where the Flatpak plugin would download any ostree trees (but not doing the deloy step) so that the applications can be updated live in the details panel without having to wait for the download to complete. In a similar way, the fwupd plugin downloads the tiny LVFS metadata with GS_PLUGIN_REFRESH_FLAGS_METADATA and then downloads the large firmware files themselves only when the GS_PLUGIN_REFRESH_FLAGS_PAYLOAD flag is set.

If the @app parameter is set for gs_plugin_download_file() then the progress of the download is automatically proxied to the UI elements associated with the application, for instance the install button would show a progress bar in the various different places in the UI. For a refresh there’s no relevant GsApp to use, so we’ll leave it NULL which means something is happening globally which the UI can handle how it wants, for instance showing a loading page at startup.

gboolean
gs_plugin_refresh (GsPlugin *plugin,
guint cache_age,
GsPluginRefreshFlags flags,
GCancellable *cancellable,
GError **error)
{

/* this is called at startup and once per day */

/* is the metadata missing or too old */
if (gs_utils_get_file_age (file) > cache_age) {
NULL,
cancellable,
error)) {
/* it's okay to fail here */
return FALSE;
}
}
}

/* this is called when the session is idle */
if ((flags & GS_PLUGIN_REFRESH_FLAGS_PAYLOAD) == 0) {
}

return TRUE;
}


Note, if the downloading fails it’s okay to return FALSE; the plugin loader continues to run all plugins and just logs an error to the console. We’ll be calling into gs_plugin_refresh() again in only a few hours, so there’s no need to bother the user. For actions like gs_plugin_app_install we also do the same thing, but we also save the error on the GsApp itself so that the UI is free to handle that how it wants, for instance showing a GtkDialog window for example.

സിപിഎമ്മിന്റെ അക്രമരാഷ്ട്രീയത്തെ എതിർത്ത് ‘ഇന്ത്യ ഭരിക്കുന്നത് ബിജെപി ആണെന്ന് ഓർക്കണം’ എന്ന് ഒരു ഗോഡ്ഫാദർ ലൈനിൽ രവിശങ്കർ പ്രസാദ്. ഭേഷ്. അതിന്റെ അർത്ഥം ‘ആർട്ടിക്കിൾ 356′ വച്ച് പിണറായെയും എംഎൽഎമാരേയും മോഡിക്ക് പിരിച്ച് വീടാനാവുമെന്നാണെന്ന് കേരളാ സംഗികൾ! ഭലേ ഭേഷ്!

Damon Lynch brings us a new release!

Community member Damon Lynch happens to make an awesome program called Rapid Photo Downloader in his “spare” time. In fact you may have heard mention of it as part of Riley Brandt’s “The Open Source Photography Course”*. It is a program that specializes in downloading photo and video from media in as efficient a manner as possible while extending the process with extra functionality.

* Riley donates a portion of the proceeds from his course to various projects, and Rapid Photo Downloader is one of them!

Work Smart, not Dumb

The main features of Rapid Photo Downloader are listed on the website:

1. Generates meaningful, user configurable file and folder names
4. Is carefully optimized to download and back up at high speed
5. Easy to configure and use
6. Runs under Unity, Gnome, KDE and other Linux desktops
7. Available in thirty languages
8. Program configuration and use is fully documented

Damon announced his 0.9.0a1 release on the forums, and Riley Brandt even recorded a short overview of the new features:

(Shortly after announcing the 0.9.0a1 release, he followed it up with a 0.9.0a2 release with some bug fixes).

Also being able to download from multiple devices in parallel, including from all cameras supported by gphoto2:

There is much, much more in this release. Damon goes into much further detail on his post in the forum, copied here:

How about its Timeline, which groups photos and videos based on how much time elapsed between consecutive shots. Use it to identify photos and videos taken at different periods in a single day or over consecutive days.

You can adjust the time elapsed between consecutive shots that is used to build the Timeline to match your shooting sessions.

For those who’ve used the older version, I’m copying and pasting from the ChangeLog, which covers most but not all changes:

• New features compared to the previous release, version 0.4.11:

• Every aspect of the user interface has been revised and modernized.

• Files can be downloaded from all cameras supported by gPhoto2, including smartphones. Unfortunately the previous version could download from only some cameras.

• Unique to Rapid Photo Downloader is its Timeline, which groups photos and videos based on how much time elapsed between consecutive shots. Use it to identify photos and videos taken at different periods in a single day or over consecutive days. A slider adjusts the time elapsed between consecutive shots that is used to build the Timeline. Time periods can be selected to filter which thumbnails are displayed.

• Thumbnails are bigger, and different file types are easier to distinguish.

• Thumbnails can be sorted using a variety of criteria, including by device and file type.

• Destination folders are previewed before a download starts, showing which subfolders photos and videos will be downloaded to. Newly created folders have their names italicized.

• The storage space used by photos, videos, and other files on the devices being downloaded from is displayed for each device. The projected storage space on the computer to be used by photos and videos about to be downloaded is also displayed.

• When downloading from more than one device, thumbnails for a particular device are briefly highlighted when the mouse is moved over the device.

• The order in which thumbnails are generated prioritizes representative samples, based on time, which is useful for those who download very large numbers of files at a time.

• Thumbnails are generated asynchronously and in parallel, using a load balancer to assign work to processes utilizing up to 4 CPU cores. Thumbnail generation is faster than the 0.4 series of program releases, especially when reading from fast memory cards or SSDs. (Unfortunately generating thumbnails for a smartphone’s photos is painfully slow. Unlike photos produced by cameras, smartphone photos do not contain embedded preview images, which means the entire photo must be downloaded and cached for its thumbnail to be generated. Although Rapid Photo Downloader does this for you, nothing can be done to speed it up).

• Thumbnails generated when a device is scanned are cached, making thumbnail generation quicker on subsequent scans.

• Libraw is used to render RAW images from which a preview cannot be extracted, which is the case with Android DNG files, for instance.

• Freedesktop.org thumbnails for RAW and TIFF photos are generated once they have been downloaded, which means they will have thumbnails in programs like Gnome Files, Nemo, Caja, Thunar, PCManFM and Dolphin. If the path files are being downloaded to contains symbolic links, a thumbnail will be created for the path with and without the links. While generating these thumbnails does slow the download process a little, it’s a worthwhile tradeoff because Linux desktops typically do not generate thumbnails for RAW images, and thumbnails only for small TIFFs.

• The program can now handle hundreds of thousands of files at a time.

• Tooltips display information about the file including name, modification time, shot taken time, and file size.

• Right click on thumbnails to open the file in a file browser or copy the path.

• When downloading from a camera with dual memory cards, an emblem beneath the thumbnail indicates which memory cards the photo or video is on

• Audio files that accompany photos on professional cameras like the Canon EOS-1D series of cameras are now also downloaded. XMP files associated with a photo or video on any device are also downloaded.

• Comprehensive log files are generated that allow easier diagnosis of program problems in bug reports. Messages optionally logged to a terminal window are displayed in color.

• When running under Ubuntu‘s Unity desktop, a progress bar and count of files available for download is displayed on the program’s launcher.

• Status bar messages have been significantly revamped.

• Determining a video’s correct creation date and time has been improved, using a combination of the tools MediaInfo and ExifTool. Getting the right date and time is trickier than it might appear. Depending on the video file and the camera that produced it, neither MediaInfo nor ExifTool always give the correct result. Moreover some cameras always use the UTC time zone when recording the creation date and time in the video’s metadata, whereas other cameras use the time zone the video was created in, while others ignore time zones altogether.

• The time remaining until a download is complete (which is shown in the status bar) is more stable and more accurate. The algorithm is modelled on that used by Mozilla Firefox.

• The installer has been totally rewritten to take advantage of Python‘s tool pip, which installs Python packages. Rapid Photo Downloader can now be easily installed and uninstalled. On Ubuntu, Debian and Fedora-like Linux distributions, the installation of all dependencies is automated. On other Linux distrubtions, dependency installation is partially automated.

• When choosing a Job Code, whether to remember the choice or not can be specified.

• Removed feature:

• Rotate Jpeg images - to apply lossless rotation, this feature requires the program jpegtran. Some users reported jpegtran corrupted their jpegs’ metadata — which is bad under any circumstances, but terrible when applied to the only copy of a file. To preserve file integrity under all circumstances, unfortunately the rotate jpeg option must therefore be removed.
• Under the hood, the code now uses:

• PyQt 5.4 +

• Python 3.4 +

• ZeroMQ for interprocess communication

• Gstreamer for video thumbnail generation

• Please note if you use a system monitor that displays network activity, don’t be alarmed if it shows increased local network activity while the program is running. The program uses ZeroMQ over TCP/IP for its interprocess messaging. Rapid Photo Downloader’s network traffic is strictly between its own processes, all running solely on your computer.

• Missing features, which will be implemented in future releases:

• Components of the user interface that are used to configure file renaming, download subfolder generation, backups, and miscellaneous other program preferences. While they can be configured by manually editing the program’s configuration file, that’s far from easy and is error prone. Meanwhile, some options can be configured using the command line.

• There are no full size photo and video previews.

• There is no error log window.

• Some main menu items do nothing.

• Files can only be copied, not moved.

Of course, Damon doesn’t sit still. He quickly followed up the 0.9.0a1 announcement by announcing 0.9.0a2 which included a few bug fixes from the previous release:

• Added command line option to import preferences from from an old program version (0.4.11 or earlier).

• Implemented auto unmount using GIO (which is used on most Linux desktops) and UDisks2 (all those desktops that don’t use GIO, e.g. KDE).

• Fixed bug while logging processes being forcefully terminated.

• Fixed bug where stored sequence number was not being correctly used when renaming files.

• Fixed bug where download would crash on Python 3.4 systems due to use of Python 3.5 only math.inf

If you’ve been considering optimizing your workflow for photo import and initial sorting now is as good a time as any - particularly with all of the great new features that have been packed into this release! Head on over to the Rapid Photo Downloader website to have a look and see the instructions for getting a copy:

Remember, this is Alpha software still (though most of the functionality is all in place). If you do run into any problems, please drop in and let Damon know in the forums!

May 21, 2016

കമ്മട്ടിപാടം, 2016 : നഗരം വിഴുങ്ങിയ ലോകത്തിന്റെ, അതിൽ പെട്ട്പോയ ജനങ്ങളുടെ ജീവിതമാണ് കമ്മട്ടിപാടത്തിന്റെ കഥ. ലീനിയർ റിയലസ്റ്റിക്ക് നറേഷനുകളിൽ നിന്ന് മാറി നോൺലീനിയർ സ്വഭാവത്തിൽ അല്പം സിനിമാറ്റിക്കായി തന്നെ രാജീവ് രവി കഥ പറയുന്നു – തന്റെ സിനിമയുടെ ശബ്ദമായ ‘ഇരകളുടെ രാഷ്ട്രീയത്തിൽ’ നിന്ന് ഒരടി മാറാതെ. എല്ലാ അഭിനയതാക്കളിൽ നിന്നും മികച്ച പ്രകടനം – അതിൽ എറ്റവും ഗംഭീരം വിനായകൻ, മണികണ്ഠൻ. പകുതിയിലേറെ പുതുമുഖങ്ങൾ, നല്ല സംഗീതം, നല്ല പശ്ചാത്തല സംഗീതം.ചില കഥാപാത്രങ്ങളുടെ ചമയം […]
ആറന്മുളയിലെ ഇലക്ഷനിൽ തനിക്കെതിരെ എറ്റവും ശക്തമായ കാമ്പ്യേനുകൾ നടത്തിയത് ഓർത്തഡോക്സ് സഭയും ഫാദർ ജോൺസൺ കല്ലേപതിയുമാണെന്നും ആ സഭ തന്റെ വിജയിത്തിന്റെ ക്രഡിറ്റ് എടുക്കേണ്ടെന്നും വീണ ജോർജ്ജ്. അങ്ങനെ സഭയ്ക്ക് സ്വന്തമായി ഒരു സുകുമാരൻ നായരായി.
വലിയ ചിറകുള്ള പക്ഷികൾ, 2015 : സിനിമാ ഭാഷയിൽ കാണിച്ച് ഫലിപ്പിക്കാവുന്ന ഒരു ദുരന്തമല്ല കാസർഗോഡ് അനുഭവിച്ച എന്റോസൽഫാൻ. ഒരു നിമിഷത്തിൽ സംഭവിച്ച ദുരന്തമല്ല, തീയില്ല, പുകയില്ല – ഞെട്ടിക്കുന്ന ദുരന്തത്തിന്റെ സ്വഭാവങ്ങൾ ഒന്നും ഇല്ല. എന്നാൽ ഇരകളുണ്ട്, ദുരിതത്തിലാണ്ട് മരിച്ച് പോയതും ജീവിക്കുന്നതുമായ ഒരുപാട് ജീവനുകളുണ്ട്. 2001 കാസർഗോഡിന്റെ നിർഭാഗ്യത്തെ വെളിച്ചത്തിലേക്ക് കൊണ്ടുവന്ന മാതൃഭൂമി ഫോട്ടോഗ്രാഫർ മധുരാജിലുടെയാണ് കഥ നീങ്ങുന്നത്. (അത് മധുരാജ് ആണെന്ന് പറയുന്നില്ല). പൊരുതിയവരിലൂടെ, ഇരകളിലൂടെ, ചർച്ചകളിലൂടെ സിനിമ അവിടത്തെ അവസ്ഥ പറയുന്നു. […]
റിസർവേഷനെതിരെ തന്റെ പേരിൽ കണ്ട ഫേസ്ബുക്ക് പോസ്റ്റുകളും പേജും തന്റെതല്ലെന്നും, തന്റെ അറിവോടെയല്ലെന്നും മെറിൻ ജോസഫ് ഐ പി എസ്. റിസർവേഷനെതിരെയുള്ള സ്ഥിരം പല്ലവികളും എന്തിന് ആന്റി അബേദ്കർ വചനങ്ങളും ഇപ്പൊ സിവിൽ സർവീസ് വിജയികളുടെ പേരിൽ ഫേസ്ബുക്കിൽ കിടന്ന് ബ്രേക്ക് ഡാൻസ് കളിക്കുന്നത് ആദ്യമായല്ല.

May 20, 2016

After quite a lot of positive feedback from my last post I’ll write some more about custom plugins. Next up is returning custom applications into the installed list. The use case here is a proprietary software distribution method that installs custom files into your home directory, but you can use your imagination for how this could be useful.

The example here is all hardcoded, and a true plugin would have to derive the details about the GsApp, for example reading in an XML file or YAML config file somewhere. So, code:

#include <gnome-software.h>

void
gs_plugin_initialize (GsPlugin *plugin)
{
}

gboolean
GsAppList *list,
GCancellable *cancellable,
GError **error)
{
g_autofree gchar *fn = NULL;
g_autoptr(GsApp) app = NULL;
g_autoptr(AsIcon) icon = NULL;

/* check if the app exists */
fn = g_build_filename (g_get_home_dir (), "chiron", NULL);
if (!g_file_test (fn, G_FILE_TEST_EXISTS))
return TRUE;

/* the trigger exists, so create a fake app */
app = gs_app_new ("example:chiron.desktop");
gs_app_set_management_plugin (app, "example");
gs_app_set_kind (app, AS_APP_KIND_DESKTOP);
gs_app_set_state (app, AS_APP_STATE_INSTALLED);
gs_app_set_name (app, GS_APP_QUALITY_NORMAL,
"Chiron");
gs_app_set_summary (app, GS_APP_QUALITY_NORMAL,
"A teaching application");
gs_app_set_description (app, GS_APP_QUALITY_NORMAL,
"Chiron is the name of an application.\n\n"
"It can be used to demo some of our features");

/* these are all optional */
gs_app_set_version (app, "1.2.3");
gs_app_set_size_installed (app, 2 * 1024 * 1024);
gs_app_set_origin_ui (app, "The example plugin");
"GPL-2.0+ and LGPL-2.1+");

/* create a stock icon (loaded by the 'icons' plugin) */
icon = as_icon_new ();
as_icon_set_kind (icon, AS_ICON_KIND_STOCK);
as_icon_set_name (icon, "input-gaming");
gs_app_set_icon (app, icon);

/* return new app */

return TRUE;
}


This shows a lot of the plugin architecture in action. Some notable points:

• The application ID (example:chiron.desktop) has a prefix of example which means we can co-exist with any package or flatpak version of the Chiron application, not setting the prefix would make the UI confused if more than one chiron.desktop got added.
• Setting the management plugin means we can check for this string when working out if we can handle the install or remove action.
• Most applications want a kind of AS_APP_KIND_DESKTOP to be visible as an application.
• The origin is where the application originated from — usually this will be something like Fedora Updates.
• The GS_APP_KUDO_INSTALLS_USER_DOCS means we get the blue “Documentation” award in the details page; there are many kudos to award to deserving apps.
• Setting the license means we don’t get the non-free warning — removing the 3rd party warning can be done using AS_APP_QUIRK_PROVENANCE
• The icons plugin will take the stock icon and convert it to a pixbuf of the correct size.

To show this fake application just compile and install the plugin, touch ~/chiron and then restart gnome-software.

By filling in the optional details (which can also be filled in using gs_plugin_refine_app() (to be covered in a future blog post) you can also make the details page a much more exciting place. Adding a set of screenshots is left as an exercise to the reader.

For anyone interested, I’m also slowly writing up these blog posts into proper docbook and uploading them with the gtk-doc files here. I think this documentation would have been really useful for the Endless and Ubuntu people a few weeks ago, so if anyone sees any typos or missing details please let me know.

കൊച്ചിൽ അമോണിയ ലീക്ക്. വൈറ്റില പ്രദേശത്താണ് സംഭവം. പനമ്പള്ളി നഗർ വരെ അതിന്റെ ഗന്ധം കിട്ടുന്നു എന്ന് റിപ്പോർട്ടുകൾ.
“നേരിൻ നോവിനു കൂട്ടിനൊയായിരമുണ്ടേ!” Muhsin Parari. Bijibal Maniyil. Mamukoya. Funeral of a Native Son. Sequel to Native Bapa.
ഇനി പ്രതിപക്ഷം. ചാണ്ടിയേക്കാളും ചെന്നിത്തലയെക്കാളും പ്രതിപക്ഷത്തിനു നല്ലത് വി ഡി സതീശൻ, അല്ലെങ്കിൽ കരുണാകര പുത്രൻ മുരളീധരൻ ആണ്.
അറിഞ്ഞില്ലേ? ചെഗ്വേരക്ക് പ്രമോഷൻ കിട്ടി, ഫിഡല്‍ കാസ്‌ട്രോ!!
മുഖ്യൻ പിണറായി. പ്രതിപക്ഷത്ത് ചാണ്ടി ഇരിക്കണോ അത് വിഎസ് തന്നെ ആ പണി തുടരുമൊ എന്ന് മാത്രം നോക്കിയാൽ മതി.
തന്റെ വികസനപദ്ധതികള്‍ തുടരണമെന്ന് പുതിയ സര്‍ക്കാരിന് ഉമ്മൻ ചാണ്ടിയുടെ ഉപദേശം. കിം ബഹൂനാ!
“ഭൂരിപക്ഷത്തിന്റത്രേം വൃക്ഷ തൈ എന്ന് പറയുമ്പോ… റബ്ബറ് നട്ടാൽ മതിയാവോ?” – സർ മാണി, പാലാ. (കാബൂളിവാല-ജഗതി.ജെപിജി)

May 19, 2016

എൽ.ഡി.എഫ് വന്നാൽ എല്ലാം ശരിയാവും എന്ന് പറഞ്ഞത് അച്ചട്ടാ, വടക്കാഞ്ചേരിയിൽ കേടുവന്ന വോട്ടിങ്ങ് യന്ത്രം വരെ ‘ശരിയായി’.
നായന്മാരുടെ പടത്തലവനു മൊഴിയാൻ സമയമായില്ലേ? മനോരമ വാരികയിലെ നോവൽ കാത്തിരിക്കുന്നത് പോലെ, സമദൂരസിദ്ധാന്തത്തിന്റെ പുതിയ അധ്യായത്തിനു വേണ്ടി കാത്തിരിക്കുന്നു!
സീറ്റുകൾ കുറഞ്ഞെങ്കിലും ചരിത്രപരമായ വിജയമാണ് ജയലളിതയുടേത്. 1980 മുതൽ 87 വരെ ഭരിച്ച എം ജി ആറിനു ശേഷം, 20 വർഷത്തിനു ശേഷമാണ് ഒരു പാർട്ടി തുടർച്ചയായി രണ്ടാമത് ഭരിക്കാൻ തയ്യാറാവുന്നത്. 234ൽ 128 സീറ്റുകളിൽ വിജയം ഉറപ്പിച്ച് ‘പുരയ്ച്ചി തലൈവി’ നിൽക്കുമ്പോൾ 23 സീറ്റിൽ നിന്നും 89 സീറ്റിലേക്ക് വളരാൻ മാത്രമെ കരുണാനിധിക്ക് സാധിച്ചുള്ളൂ. ഗ്യാപ്റ്റൻ വിജയ്കാന്താണ് അവിടത്തെ ‘ഭീമൻ രഘു’, ഒരു സീറ്റ് പോലുമില്ല.
“ഇത് പിണറായി വിജയനു വേണ്ടിയോ വി.എസ്. അച്യുതാനന്ദനുവേണ്ടിയോ ഉയര്‍ന്ന ആരവമല്ല. ഇത് സുധീരനോടോ രമേശ് ചെന്നിത്തലയോടോ ഉള്ള ഈര്‍ഷ്യയുമല്ല. ദേഹത്താകെ പടര്‍ന്ന പോലെ മലയാളികളെയാകെ അസ്വസ്ഥമാക്കിയ ഒരു രാഷ്ട്രീയ മാലിന്യത്തെ കഴുകിക്കളയാനുള്ള ആദ്യ അവസരം മലയാളികള്‍ വിനിയോഗിക്കുകയായിരുന്നു. പച്ചില കൂട്ടിപ്പിടിച്ച് ഓരത്തേക്ക് കളയേണ്ട ആ ജീര്‍ണതയ്ക്ക് നേതൃത്വം നല്‍കിയത് ഉമ്മന്‍ചാണ്ടി എന്ന രാഷ്ട്രീയ നേതാവാണ്.” എം പി ബഷീറിന്റെ ഗംഭീര ലേഖനം.
ബംഗാളിലെ ‘പാർട്ടിയുടെ’ അവസ്ഥ വച്ച് നോക്കുമ്പോൾ തമിഴ്നാട്, ബംഗാൾ, കേരളം എന്നിവിടങ്ങളിൽ ‘പ്രാദേശിക പാർട്ടികൾ’ ജയിച്ചു എന്ന് പറയുന്നതിൽ തെറ്റില്ല.. ല്ലേ?

I’ve just pushed a set of patches to gnome-software master that allow people to compile out-of-tree gnome-software plugins.

In general, building things out-of-tree isn’t something that I think is a very good idea; the API and ABI inside gnome-software is still changing and there’s a huge benefit to getting plugins upstream where they can undergo review and be ported as the API adapts. I’m also super keen to provide configurability in GSettings for doing obviously-useful things, the sort of thing Fleet Commander can set for groups of users. However, now we’re shipping gnome-software in enterprise-class distros we might want to allow customers to ship thier own plugins to make various business-specific changes that don’t make sense upstream. This might involve querying a custom LDAP server and changing the suggested apps to reflect what groups the user is in, or might involve showing a whole new class of applications that does not conform to the Linux-specific “application is a desktop-file” paradigm. This is where a plugin makes sense, and something I’d like to support in future updates to RHEL 7.

At this point it probably makes sense to talk a bit about how the architecture of gnome-software works. At its heart it’s just a big plugin loader that has some GTK UI that gets created for various result types. The idea is we have lots of small plugins that each do one thing and then pass the result onto the other plugins. These are ordered by dependencies against each other at runtime and each one can do things like editing an existing application or adding a new application to the result set. This is how we can add support for things like firmware updating, Steam, GNOME Shell web-apps and flatpak bundles without making big changes all over the source tree.

There are broadly 3 types of plugin methods:

• Actions: Do something on a specific GsApp; install gimp.desktop
• Refine: Get details about a specific GsApp; is firefox.desktop installed? or get reviews for inkscape.desktop
• Adopt: Can this plugin handle this GsApp; can fwupd handle com.hughski.ColorHug2.firmware

You only need to define the vfuncs that the plugin needs, and the name is taken automatically from the suffix of the .so file. So, lets look at a sample plugin one chunk at a time, taking it nice and slow. First the copyright and licence (it only has to be GPLv2+ if it’s headed upstream):

/*
* Copyright (C) 2016 Richard Hughes
*/


Then, the magic header that sucks in everything that’s exported:

#include <gnome-software.h>


Then we have to define when our plugin is run in reference to other plugins, as we’re such a simple plugin we’re relying on another plugin to run after us to actually make the GsApp “complete”, i.e. adding icons and long descriptions:

void
gs_plugin_initialize (GsPlugin *plugin)
{
}


Then we can start to do something useful. In this example I want to show GIMP as a result (from any provider, e.g. flatpak or a distro package) when the user searches exactly for fotoshop. There is no prefixing or stemming being done for simplicity.

gboolean
gchar **values,
GsAppList *list,
GCancellable *cancellable,
GError **error)
{
guint i;
for (i = 0; values[i] != NULL; i++) {
if (g_strcmp0 (values[i], "fotoshop") == 0) {
g_autoptr(GsApp) app = gs_app_new ("gimp.desktop");
}
}
return TRUE;
}


We can then easily build and install the plugin using:

gcc -shared -o libgs_plugin_example.so gs-plugin-example.c -fPIC \
pkg-config --libs --cflags gnome-software \
-DI_KNOW_THE_GNOME_SOFTWARE_API_IS_SUBJECT_TO_CHANGE &&
sudo cp libgs_plugin_example.so pkg-config gnome-software --variable=plugindir


I’m going to be cleaning up the exported API and adding some more developer documentation before I release the next tarball, but if this is useful to you please let me know and I’ll do some more blog posts explaining more how the internal architecture of gnome-software works, and how you can do different things with plugins.

പാലാക്കരുടെ മുത്ത്, സത്യത്തിന്റെ കാവൽ ഭടൻ, നന്മയുടെ അപോസ്തലൻ, ഉസ്സൈൻ ബോൽട്ടിന്റെ 100 മീറ്റർ സ്പീഡിനേക്കാളും ബലിയ സ്പീഡിൽ ലഡു തിന്ന് ബഡ്ജറ്റ് അവതരിപ്പിച്ച സർ മാണി സാർ ജയിച്ചിരിക്കുന്നു! പ്രൈസ് ദ ലോർഡ്!
വെറും 89 വോട്ടിനാണ് കെ. സുരേന്ദ്രൻ അബ്ദുൾ റസാഖിനോട് തോറ്റത്. അപര സ്ഥാനാർത്ഥിയായ ‘കെ. സുന്ദരനു’ 460 <abbr title="U+0008">�</abbr>വോട്ടുണ്ട്. മിഷ്യനിൽ ‘ഉള്ളി സുരേന്ദ്രൻ’ എന്നെഴുതിയിരുന്നെങ്കിൽ ഈ കൺഫ്യൂഷൻ ഇല്ലാതെ ജയിക്കാമായിരുന്നു!
ഇനി വരുന്ന പത്താം ക്ലാസിലെ വിദ്യാർത്ഥികളോട് : പോയി പഠിക്കടാ ചെക്കാ!! രക്ഷിക്കാൻ ഇനി റബ്ബൊന്നുമില്ല!
എൻഡിഎക്ക് ഒരു സീറ്റ്. അതും ‘കൊതിപ്പിച്ച് പല തവണ നഷ്ടപ്പെട്ട’ രാജഗോപാലിനു തന്നെ. ആശംസകൾ. പല സ്ഥലങ്ങളിലും രണ്ടാമനാവാൻ ബിജെപിക്ക് സാധിച്ചു. നൂലിൽ കെട്ടിയിറക്കിയ ശ്രീശാന്ത് പോലുള്ളവരേയും വെള്ളാപ്പള്ളിയേയും ഒഴിവാക്കി പഴയ പാർട്ടിക്കാർക്ക് കൂടുതൽ സീറ്റുകൾ കൊടുത്തിരുന്നെങ്കിൽ നല്ല ബേസ് ഉണ്ടാക്കാൻ കഴിഞ്ഞേനെ. എന്തായാലും ഉടൻ തന്നെ വെള്ളാപ്പള്ളിയുടെ കാര്യത്തിൽ തീരുമാനം ആവും. (വീരേന്ദ്രകുമാറിനോടോ സുരേഷ് ഗോപിയോടോ ചോദിച്ച് തുഷാറിനുള്ള കിഴി തയ്യാറാക്കുക)
നികേഷിന്റെ തോൽവി : തോറ്റ സ്ഥിതിക്ക് ഇനി വാർത്ത വായിക്കാൻ തിരിച്ച് വരും എന്നത് തെറ്റായ ധാരണയാണ്. എൽഡിഎഫ് ഭരണ കക്ഷി ആവുന്നതോടെ അതിലെ ശക്തനായ ഒരു സ്പോക്സ് പർസൺ ആയി നികേഷ് മാറാൻ സാധ്യത ഏറെയാണ്. പാർട്ടി സ്പോക്സ് പർസണിൽ നിന്ന് എംപി ഇലക്ഷനും അല്ലെങ്കിൽ രാജ്യസഭാ സീറ്റും അത്ര വിദൂരമല്ല.<abbr title="U+0008">�</abbr>

Then we shall all burn together by Philipp Haegi.

￼ A new version 1.7.1Spring 2016” of G’MIC (GREYC’s Magic for Image Computing),
the open-source framework for image processing, has been released recently (26 April 2016). This is a great opportunity to summarize some of the latest advances and features over the last 5 months.

G’MIC: A brief overview

G’MIC is an open-source project started in August 2008. It has been developed in the IMAGE team of the GREYC laboratory from the CNRS (one of the major French public research institutes). This team is made up of researchers and teachers specializing in the algorithms and mathematics of image processing. G’MIC is released under the free software licence CeCILL (GPL-compatible) for various platforms (Linux, Mac and Windows). It provides a set of various user interfaces for the manipulation of generic image data, that is images or image sequences of multispectral data being 2D or 3D, and with high-bit precision (up to 32bits floats per channel). Of course, it manages “classical” color images as well.

Note that the project just got a redesign of its mascot Gmicky, drawn by David Revoy, a French illustrator well-known to free graphics lovers for being responsible for the great libre webcomics Pepper&CarottG’MIC is probably best known for it’s GIMP plug-in, first released in 2009. Today, this popular GIMP extension proposes more than 460 customizable filters and effects to apply on your images.

But G’MIC is not a plug-in for GIMP only. It also offers a command-line interface, that can be used in addition with the CLI tools from ImageMagick or GraphicsMagick (this is undoubtly the most powerful and flexible interface of the framework). G’MIC also has a web service G’MIC Online to apply effects on your images directly from a web browser. Other G’MIC-based interfaces also exist (ZArt, a plug-in for Krita, filters for Photoflow…). All these interfaces are based on the generic C++ libraries CImg and libgmic which are portable, thread-safe and multi-threaded (through the use of OpenMP). Today, G’MIC has more than 900 functions to process images, all being fully configurable, for a library of only approximately 150 kloc of source code. It’s features cover a wide spectrum of the image processing field, with algorithms for geometric and color manipulations, image filtering (denoising/sharpening with spectral, variational or patch-based approaches…), motion estimation and registration, drawing of graphic primitives (up to 3d vector objects), edge detection, object segmentation, artistic rendering, etc. This is a versatile tool, useful to visualize and explore complex image data, as well as elaborate custom image processing pipelines (see these slides to get more information about the motivations and goals of the G’MIC project).

A selection of some new filters and effects

Here we look at the descriptions of some of the most significant filters recently added. We illustrate their usage from the G’MIC plug-in for GIMP. All of these filters are of course available from other interfaces as well (in particular within the CLI tool gmic).

Painterly rendering of photographs

The filter Artistic / Brushify tries to transform an image into a painting. Here, the idea is to simulate the process of painting with brushes on a white canvas. One provides a template image and the algorithm first analyzes the image geometry (local contrasts and orientations of the contours), then attempt to reproduce the image with a single brush that will be locally rotated and scaled accordingly to the contour geometry. By simulating enough of brushstrokes, one gets a “painted” version of the template image, which is more or less close to the original one, depending on the brush shape, its size, the number of allowed orientations, etc. All these settings being customizable by the user as parameters of the algorithm: This filter allows thus to render a wide variety of painting effects.

The animation below illustrates the diversity of results one can get with this filter, applied on the same input picture of a lion. Various brush shapes and geometries have been supplied to the algorithm. Brushify is computationally expensive so its implementation is parallelized (each core gives several brushstrokes simultaneously).

Note that it’s particularly fun to invoke this filter from the command line interface (using the option -brushify available in gmic) to process a sequence of video frames (see this example of “ brushified “ video):

Reconstructing missing data from sparse samples

G’MIC gets a new algorithm to reconstruct missing data in images. This is a classical problem in image processing, often named “Image Inpainting“, and G’MIC already had a lot of useful filters to solve this problem. Here, the newly added interpolation method assumes only a sparse set of image data is known, for instance a few scattered pixels over the image (instead of continuous chuncks of image data). The analysis and the reconstruction of the global image geometry is then particularly tough.

The new option -solidify in G’MIC allows the reconstruction of dense image data from such a sparse sampling, based on a multi-scale diffusion PDE’s-based technique. The figure below illustrates the ability of the algorithm with an example of image reconstruction. We start from an input image of a waterdrop, and we keep only 2.7% of the image data (a very little amount of data!). The algorithm is able to reconstruct a whole image that looks like the input, even if all the small details have not been fully reconstructed (of course!). The more samples we have, the finer details we can recover.

As this reconstruction technique is quite generic, several new G’MIC filters takes advantage of it:

• Filter Repair / Solidify applies the algorithm in a direct manner, by reconstructing transparent areas from the interpolation of opaque regions. The animation below shows how this filter can be used to create an artistic blur on the image borders.

From an artistic point of view, there are many possibilities offered by this filters. For instance, it becomes really easy to generate color gradients with complex shapes, as shown with the two examples below (also in this video that details the whole process).

• Filter Artistic / Smooth abstract uses same idea as the one with the waterdrop image: it purposely sub-samples the image in a sparse way, by choosing keypoints mainly on the image edges, then use the reconstruction algorithm to get the image back. With a low number of samples, the filter can only render a piecewise smooth image, i.e. a smooth abstraction of the input image.
• Filter Rendering / Gradient [random] is able to synthetize random colored backgrounds. Here again, the filter initializes a set of colors keypoints randomly chosen over the image, then interpolate them with the new reconstruction algorithm. We end up with a psychedelic background composed of randomly oriented color gradients.
• Simulation of analog films : the new reconstruction algorithm also allowed a major improvement for all the analog film emulation filters that have been present in G’MIC for years. The section Film emulation/ proposes a wide variety of filters for this purpose. Their goal is to apply color transformations to simulate the look of a picture shot by an analogue camera with a certain kind of film. Below, you can see for instance a few of the 300 colorimetric transformations that are available in G’MIC.

From an algorithmic point of view, such a color mapping is extremely simple to implement : for each of the 300+ presets, G’MIC actually has an HaldCLUT, that is a function defining for each possible color (R,G,B) (of the original image), a new color (R’,G’,B’) color to set instead. As this function is not necessarily analytic, a HaldCLUT is stored in a discrete manner as a lookup table that gives the result of the mapping for all possible colors of the RGB cube (that is 2^24 = 16777216 values if we work with a 8bits precision per color component). This HaldCLUT-based color mapping is illustrated below for all values of the RGB color cube.

This is a large amount of data: even by subsampling the RGB space (e.g. with 6 bits per component) and compressing the corresponding HaldCLUT file, you ends up with approximately 200 and 300 kB for each mapping file. Multiply this number by 300+ (the number of available mappings in G’MIC), and you get a total of 85MB of data, to store all these color transformations. Definitely not convenient to spread and package!

The idea was then to develop a new lossy compression technique focused on HaldCLUT files, that is volumetric discretised vector-valued functions which are piecewise smooth by nature. And that what has been done in G’MIC, thanks to the new sparse reconstruction algorithm. Indeed, the reconstruction technique also works with 3D image data (such as a HaldCLUT!), so one simply has to extract a sufficient number of significant keypoints in the RGB cube and interpolate them afterwards to allow the reconstruction of a whole HaldCLUT (taking care to have a reconstruction error small enough to be sure that the color mapping we get with the compressed HaldCLUT is indistinguishable from the non-compressed one).

Thus, G’MIC doesn’t need to store all the color data from a HaldCLUT, but only a sparse sampling of it (i.e. a sequence of { rgb_keypoint, new_rgb_color }). Depending on the geometric complexity of the HaldCLUTs to encode, more or less keypoints are necessary (roughly from 30 to 2000). As a result, the storage of the 300+ HaldCLUTs in G’MIC requires now only 850 KiB of data (instead of 85 MiB), that is a compression gain of 99% ! That makes the whole HaldCLUT data storable in a single file that is easy to ship with the G’MIC package. Now, a user can then apply all the G’MIC color transformations while being offline (previously, each HaldCLUT had to be downloaded separately from the G’MIC server when requested).

It looks like this new reconstruction algorithm from sparse samples is really great, and no doubts it will be used in other filters in the future.

Make textures tileable

Filter Arrays & tiles / Make seamless [patch-based] tries to transform an input texture to make it tileable, so that it can be duplicated as tiles along the horizontal and vertical axes without visible seams on the borders of adjacent tiles. Note that this is something that can be extremely hard to achieve, if the input texture has few auto-similarity or glaring luminosity changes spatially. That is the case for instance with the “Salmon” texture shown below as four adjacent tiles (configuration 2×2) with a lighting that goes from dark (on the left) to bright (on the right). Here, the algorithm modifies the texture so that the tiling shows no seams, but where the aspect of the original texture is preserved as much as possible (only the texture borders are modified).

We can imagine some great uses of this filter, for instance in video games, where texture tiling is common to render large virtual worlds.

Image decomposition into several levels of details

A “new” filter Details / Split details [wavelets] has been added to decompose an image into several levels of details. It is based on the so-called “à trous” wavelet decomposition. For those who already know the popular Wavelet Decompose plug-in for GIMP, there won’t be so much novelty here, as it is mainly the same kind of decomposition technique that has been implemented. Having it directly in G’MIC is still a great news: it offers now a preview of the different scales that will be computed, and the implementation is parallelized to take advantage of multiple cores.

The filter outputs several layers, so that each layer contains the details of the image at a given scale. All those layers blended together gives the original image back. Thus, one can work on those output layers separately and modify the image details only for a given scale. There are a lot of applications for this kind of image decomposition, one of the most spectacular being the ability to retouch the skin in portraits : the flaws of the skin are indeed often present in layers with middle-sized scales, while the natural skin texture (the pores) are present in the fine details. By selectively removing the flaws while keeping the pores, the skin aspect stays natural after the retouch (see this wonderful link for a detailed tutorial about skin retouching techniques, with GIMP).

Image denoising based on “Patch-PCA”

G’MIC is also well known to offer a wide range of algorithms for image denoising and smoothing (currently more than a dozen). And he got one more ! Filter Repair / Smooth [patch-pca] proposed a new image denoising algorithm that is both efficient and computationally intensive (despite its multi-threaded implementation, you probably should avoid it on a machine with less than 8 cores…). In return, it sometimes does magic to suppress noise while preserving small details.

The “Droste” effect

The Droste effect (also known as “mise en abyme“ in art) is the effect of a picture appearing within itself recursively. To achieve this, a new filter Deformations / Continuous droste has been added into G’MIC. It’s actually a complete rewrite of the popular Mathmap’s Droste filter that has existed for years. Mathmap was a very popular plug-in for GIMP, but it seems to be not maintained anymore. The Droste effect was one of its most iconic and complex filter. Martin “Souphead”, one former user of Mathmap then took the bull by the horns and converted the complex code of this filter specifically into a G’MIC script, resulting in a parallelized implementation of the filter.

This filter allows all artistic delusions. For instance, it becomes trivial to create the result below in a few steps: create a selection around the clock, move it on a transparent background, run the Droste filter, et voilà!.

The filter Deformations / Equirectangular to nadir-zenith is another filter converted from Mathmap to G’MIC. It is specifically used for the processing of panoramas: it reconstructs both the Zenith and the
Nadir regions of a panorama so that they can be easily modified (for instance to reconstruct missing parts), before being reprojected back into the input panorama.

Morgan Hardwood has wrote a quite detailled tutorial, on pixls.us, about the reconstruction of missing parts in the Zenith/Nadir of an equirectangular panorama. Check it out!

Other various improvements

Finally, here are other highlights about the G’MIC project:

• Filter Rendering / Kitaoka Spin Illusion is another Mathmap filter converted to G’MIC by Martin “Souphead”. It generates a certain kind of optical illusions as shown below (close your eyes if you are epileptic!)
• Filter Colors / Color blindness transforms the colors of an image to simulate different types of color blindness. This can be very helpful to check the accessibility of a web site or a graphical document for colorblind people. The color transformations used here are the same as defined on Coblis, a website that proposes to apply this kind of simulation online. The G’MIC filter gives strictly identical results, but it ease the batch processing of several images at once.
• Since a few years now, G’MIC has its own parser of mathematical expression, a really convenient module to perform complex calculations when applying image filters This core feature gets new functionalities: the ability to manage variables that can be complex, vector or matrix-valued, but also the creation of user-defined mathematical functions. For instance, the classical rendering of the Mandelbrot fractal set (done by estimating the divergence of a sequence of complex numbers) can be implemented like this, directly on the command line:
$gmic 512,512,1,1,"c = 2.4*[x/w,y/h] - [1.8,1.2]; z = [0,0]; for (iter = 0, cabs(z) This clearly enlarge the math evaluator ability, as you are not limited to scalar variables anymore. You can now create complex filters which are able to solve linear systems or compute eigenvalues/eigenvectors, and this, for each pixel of an input image. It’s a bit like having a micro-(micro!)-Octave inside G’MIC. Note that the Brushify filter described earlier uses these new features extensively. It’s also interesting to know that the G’MIC math expression evaluator has its own JIT compiler to achieve a fast evaluation of expressions when applied on thousands of image values simultaneously. • Another great contribution has been proposed by Tobias Fleischer, with the creation of a new API to invoke the functions of the libgmic library (which is the library containing all the G’MIC features, initially available through a C++ API only). As the C ABI is standardized (unlike C++), this basically means G’MIC can be interfaced more easily with languages other than C++. In the future, we can imagine the development of G’MIC APIs for languages such as Python for instance. Tobias is currently using this new C API to develop G’MIC-based plug-ins compatible with the OpenFX standard. Those plug-ins should be usable indifferently in video editing software such as After effects, Sony Vegas Pro or Natron. This is still an on-going work though. • You can find out G’MIC filters also in the opensource nonlinear video editor Flowblade, thanks to the hard work of Janne Liljeblad (Flowblade project leader). Here again, the goal is to allow the application of G’MIC effects and filters directly on image sequences, mainly for artistic purposes (as shown in this video or this one). What’s next ? As you see, the G’MIC project is doing well, with an active development and cool new features added months after months. You can find and use interfaces to G’MIC in more and more opensource software, as GIMPKritaBlenderPhotoflowFlowbladeVeejayEKD and Natron in a near future (at least we hope so!). At the same time, we can see more and more external resources available for G’MIC : tutorials, blog articles (hereherehere,…), or demonstration videos (herehereherehere,…). This shows the project becoming more useful to users of opensource software for graphics and photography. The development of version 1.7.2 already hit the ground running, so stay tuned and visit the official G’MIC forum on pixls.us to get more info about the project developement and get answers to your questions. Meanwhile, feel the power of free software for image processing! ഇലക്ഷൻ കമ്മീഷാ, ഇലക്ഷൻ കമ്മീഷാ, വാർത്ത നികേഷിനെ കൊണ്ട് വായിപ്പിച്ചൂടേ? May 18, 2016 We’re getting closer and closer to releasing Krita 3.0, the first version of Krita that includes animation tools, instant preview and which is based on Qt5! Today’s release candidate offers many fixes and improvements over the previous beta releases. The Animation and Instant Preview features were funded by last year’s successful Kickstarter, and right now we’re running our third Kickstarter campaign: this year’s main topics are creating a great text and vector toolset. After one week, we’re already half-way! The biggest new feature is no doubt support for hand-drawn animation. This summer, Jouni Pentikäinen will continue improving the animation tools, but it’s already a solid toolset. Here’s a video tutorial where Wolthera shows how she created the animated headers for this year’s Kickstarter stretch goals: And here is another demonstration by Wolthera showing off the Instant Preview feature, which makes it possible to use big brushes on big canvases. It may take a bit more memory, but it gives a huge speed boost: Apart from Instant Preview, Animation, Qt5-support, Krita 3.0 will have a number of Kickstarter stretch goals, like improved layer handling, improved shortcuts, the tangent normal brush, and great colorspace selector, guides, a grids and guides docker, snapping to grids and guides, improved shortcut palette, gradient map filter and much, much, much more. And we’ll be sure to fix more issues before we present the final release. So check out the review prepared by Nathan Lovato, while we’re preparing the full release announcement: Release Candidate 3 Improvements Compared to the last beta, we’ve got the following improvements: • Shortcuts now also work if the cursor is not hovering over the canvas • Translations are more complete • The export to PDF dialog shows the page preview • The advanced color selector is faster • The vector gradient tool performs petter • Fill layers are saved and loaded correctly • Improvements to Instant Preview • Fix crashes when setting font properties in the text tool. • Fix handling the mirror axis handle • Use OpenMP in G’Mic on Windows and Linux, which makes most filters much faster • Fixes to the file dialog • The Spriter export plugin was rewritten • Fix a number of crashes • Fix the scaling of the toolbox icons • Add new icons for the pan and zoom tools • Make it possible to enable HiDPI mode by setting the environment variable KRITA_HIDPI to ON. • Fix the fade, distance and time sensors in the brush editor • Make it possible to open color palettes again • Add a shortcut for toggling onion skinning • Fix loading of the onion skin button states • Add a lock for the brush drawing angle • Handle positioning popups and dialogs on multi-monitor setups correctly And a load of smaller things! Downloads Windows Shell Extension package by Alvin Wong. Just install it and Windows Explorer will start showing preview and meta information for Krita files. (Disregard any warnings by virus checkers, because this package is built with the NSIS installer maker, some virus checkers always think it’s infected, it’s not.) Windows: Unzip and run the bin/krita.exe executable! These downloads do not interfere with your existing installation. The configuration file location has been moved from %APPDATA%\Local\kritarc to %APPDATA%\Local\krita\kritarc. The OSX disk image still has the known issue that if OpenGL is enabled, the brush outline cursor, grids, guides and so on are not visible. We’re working on that, but don’t expect to have rewritten the canvas before 3.0 will be released. Disable OpenGL in the preferences dialog to see a cursor outline, grids and guides and so on. The Linux appimage:After downloading, make the appimage executable and run it. No installation is needed. For CentOS 6 and Ubuntu 12.04, a separate appimage is provided with g’mic built without OpenMP (which makes it much slower) As usual, you can use these builds without affecting your 2.9 installation. Source: you can find the source here: G'MIC 1.7.1 When the flowers are blooming, image filters abound! A new version 1.7.1Spring 2016” of G’MIC (GREYC’s Magic for Image Computing), the open-source framework for image processing, has been released recently (26 April 2016). This is a great opportunity to summarize some of the latest advances and features over the last 5 months. G’MIC: A brief overview G’MIC is an open-source project started in August 2008. It has been developed in the IMAGE team of the GREYC laboratory from the CNRS (one of the major French public research institutes). This team is made up of researchers and teachers specializing in the algorithms and mathematics of image processing. G’MIC is released under the free software licence CeCILL (GPL-compatible) for various platforms (Linux, Mac and Windows). It provides a set of various user interfaces for the manipulation of generic image data, that is images or image sequences of multispectral data being 2D or 3D, and with high-bit precision (up to 32bits floats per channel). Of course, it manages “classical” color images as well. Note that the project just got a redesign of its mascot Gmicky, drawn by David Revoy, a French illustrator well-known to free graphics lovers for being responsible for the great libre webcomics Pepper&Carott. G’MIC is probably best known for it’s GIMP plug-in, first released in 2009. Today, this popular GIMP extension proposes more than 460 customizable filters and effects to apply on your images. But G’MIC is not a plug-in for GIMP only. It also offers a command-line interface, that can be used in addition with the CLI tools from ImageMagick or GraphicsMagick (this is undoubtly the most powerful and flexible interface of the framework). G’MIC also has a web service G’MIC Online to apply effects on your images directly from a web browser. Other G’MIC-based interfaces also exist (ZArt, a plug-in for Krita, filters for Photoflow…). All these interfaces are based on the generic C++ libraries CImg and libgmic which are portable, thread-safe and multi-threaded (through the use of OpenMP). Today, G’MIC has more than 900 functions to process images, all being fully configurable, for a library of only approximately 150 kloc of source code. It’s features cover a wide spectrum of the image processing field, with algorithms for geometric and color manipulations, image filtering (denoising/sharpening with spectral, variational or patch-based approaches…), motion estimation and registration, drawing of graphic primitives (up to 3d vector objects), edge detection, object segmentation, artistic rendering, etc. This is a versatile tool, useful to visualize and explore complex image data, as well as elaborate custom image processing pipelines (see these slides to get more information about the motivations and goals of the G’MIC project). A selection of some new filters and effects Here we look at the descriptions of some of the most significant filters recently added. We illustrate their usage from the G’MIC plug-in for GIMP. All of these filters are of course available from other interfaces as well (in particular within the CLI tool gmic). Painterly rendering of photographs The filter Artistic / Brushify tries to transform an image into a painting. Here, the idea is to simulate the process of painting with brushes on a white canvas. One provides a template image and the algorithm first analyzes the image geometry (local contrasts and orientations of the contours), then attempt to reproduce the image with a single brush that will be locally rotated and scaled accordingly to the contour geometry. By simulating enough of brushstrokes, one gets a “painted” version of the template image, which is more or less close to the original one, depending on the brush shape, its size, the number of allowed orientations, etc. All these settings being customizable by the user as parameters of the algorithm: This filter allows thus to render a wide variety of painting effects. The animation below illustrates the diversity of results one can get with this filter, applied on the same input picture of a lion. Various brush shapes and geometries have been supplied to the algorithm. Brushify is computationally expensive so its implementation is parallelized (each core gives several brushstrokes simultaneously). Note that it’s particularly fun to invoke this filter from the command line interface (using the option -brushify available in gmic) to process a sequence of video frames (see this example of “ brushified “ video): Reconstructing missing data from sparse samples G’MIC gets a new algorithm to reconstruct missing data in images. This is a classical problem in image processing, often named “Image Inpainting“, and G’MIC already had a lot of useful filters to solve this problem. Here, the newly added interpolation method assumes only a sparse set of image data is known, for instance a few scattered pixels over the image (instead of continuous chuncks of image data). The analysis and the reconstruction of the global image geometry is then particularly tough. The new option -solidify in G’MIC allows the reconstruction of dense image data from such a sparse sampling, based on a multi-scale diffusion PDE’s-based technique. The figure below illustrates the ability of the algorithm with an example of image reconstruction. We start from an input image of a waterdrop, and we keep only 2.7% of the image data (a very little amount of data!). The algorithm is able to reconstruct a whole image that looks like the input, even if all the small details have not been fully reconstructed (of course!). The more samples we have, the finer details we can recover. As this reconstruction technique is quite generic, several new G’MIC filters takes advantage of it: • Filter Repair / Solidify applies the algorithm in a direct manner, by reconstructing transparent areas from the interpolation of opaque regions. The animation below shows how this filter can be used to create an artistic blur on the image borders. From an artistic point of view, there are many possibilities offered by this filters. For instance, it becomes really easy to generate color gradients with complex shapes, as shown with the two examples below (also in this video that details the whole process). • Filter Artistic / Smooth abstract uses same idea as the one with the waterdrop image: it purposely sub-samples the image in a sparse way, by choosing keypoints mainly on the image edges, then use the reconstruction algorithm to get the image back. With a low number of samples, the filter can only render a piecewise smooth image, i.e. a smooth abstraction of the input image. • Filter Rendering / Gradient [random] is able to synthetize random colored backgrounds. Here again, the filter initializes a set of colors keypoints randomly chosen over the image, then interpolate them with the new reconstruction algorithm. We end up with a psychedelic background composed of randomly oriented color gradients. • Simulation of analog films : the new reconstruction algorithm also allowed a major improvement for all the analog film emulation filters that have been present in G’MIC for years. The section Film emulation/ proposes a wide variety of filters for this purpose. Their goal is to apply color transformations to simulate the look of a picture shot by an analogue camera with a certain kind of film. Below, you can see for instance a few of the 300 colorimetric transformations that are available in G’MIC. From an algorithmic point of view, such a color mapping is extremely simple to implement : for each of the 300+ presets, G’MIC actually has an HaldCLUT, that is a function defining for each possible color (R,G,B) (of the original image), a new color (R’,G’,B’) color to set instead. As this function is not necessarily analytic, a HaldCLUT is stored in a discrete manner as a lookup table that gives the result of the mapping for all possible colors of the RGB cube (that is 2^24 = 16777216 values if we work with a 8bits precision per color component). This HaldCLUT-based color mapping is illustrated below for all values of the RGB color cube. This is a large amount of data: even by subsampling the RGB space (e.g. with 6 bits per component) and compressing the corresponding HaldCLUT file, you ends up with approximately 200 and 300 kB for each mapping file. Multiply this number by 300+ (the number of available mappings in G’MIC), and you get a total of 85MB of data, to store all these color transformations. Definitely not convenient to spread and package! The idea was then to develop a new lossy compression technique focused on HaldCLUT files, that is volumetric discretised vector-valued functions which are piecewise smooth by nature. And that what has been done in G’MIC, thanks to the new sparse reconstruction algorithm. Indeed, the reconstruction technique also works with 3D image data (such as a HaldCLUT!), so one simply has to extract a sufficient number of significant keypoints in the RGB cube and interpolate them afterwards to allow the reconstruction of a whole HaldCLUT (taking care to have a reconstruction error small enough to be sure that the color mapping we get with the compressed HaldCLUT is indistinguishable from the non-compressed one). Thus, G’MIC doesn’t need to store all the color data from a HaldCLUT, but only a sparse sampling of it (i.e. a sequence of { rgb_keypoint, new_rgb_color }). Depending on the geometric complexity of the HaldCLUTs to encode, more or less keypoints are necessary (roughly from 30 to 2000). As a result, the storage of the 300+ HaldCLUTs in G’MIC requires now only 850 KiB of data (instead of 85 MiB), that is a compression gain of 99% ! That makes the whole HaldCLUT data storable in a single file that is easy to ship with the G’MIC package. Now, a user can then apply all the G’MIC color transformations while being offline (previously, each HaldCLUT had to be downloaded separately from the G’MIC server when requested). It looks like this new reconstruction algorithm from sparse samples is really great, and no doubts it will be used in other filters in the future. Make textures tileable Filter Arrays & tiles / Make seamless [patch-based] tries to transform an input texture to make it tileable, so that it can be duplicated as tiles along the horizontal and vertical axes without visible seams on the borders of adjacent tiles. Note that this is something that can be extremely hard to achieve, if the input texture has few auto-similarity or glaring luminosity changes spatially. That is the case for instance with the “Salmon” texture shown below as four adjacent tiles (configuration 2x2) with a lighting that goes from dark (on the left) to bright (on the right). Here, the algorithm modifies the texture so that the tiling shows no seams, but where the aspect of the original texture is preserved as much as possible (only the texture borders are modified). We can imagine some great uses of this filter, for instance in video games, where texture tiling is common to render large virtual worlds. Image decomposition into several levels of details A “new” filter Details / Split details [wavelets] has been added to decompose an image into several levels of details. It is based on the so-called “à trous” wavelet decomposition. For those who already know the popular Wavelet Decompose plug-in for GIMP, there won’t be so much novelty here, as it is mainly the same kind of decomposition technique that has been implemented. Having it directly in G’MIC is still a great news: it offers now a preview of the different scales that will be computed, and the implementation is parallelized to take advantage of multiple cores. The filter outputs several layers, so that each layer contains the details of the image at a given scale. All those layers blended together gives the original image back. Thus, one can work on those output layers separately and modify the image details only for a given scale. There are a lot of applications for this kind of image decomposition, one of the most spectacular being the ability to retouch the skin in portraits : the flaws of the skin are indeed often present in layers with middle-sized scales, while the natural skin texture (the pores) are present in the fine details. By selectively removing the flaws while keeping the pores, the skin aspect stays natural after the retouch (see this wonderful link for a detailed tutorial about skin retouching techniques, with GIMP). Image denoising based on “Patch-PCA” G’MIC is also well known to offer a wide range of algorithms for image denoising and smoothing (currently more than a dozen). And he got one more ! Filter Repair / Smooth [patch-pca] proposed a new image denoising algorithm that is both efficient and computationally intensive (despite its multi-threaded implementation, you probably should avoid it on a machine with less than 8 cores…). In return, it sometimes does magic to suppress noise while preserving small details. The “Droste” effect The Droste effect (also known as “mise en abyme“ in art) is the effect of a picture appearing within itself recursively. To achieve this, a new filter Deformations / Continuous droste has been added into G’MIC. It’s actually a complete rewrite of the popular Mathmap’s Droste filter that has existed for years. Mathmap was a very popular plug-in for GIMP, but it seems to be not maintained anymore. The Droste effect was one of its most iconic and complex filter. Martin “Souphead”, one former user of Mathmap then took the bull by the horns and converted the complex code of this filter specifically into a G’MIC script, resulting in a parallelized implementation of the filter. This filter allows all artistic delusions. For instance, it becomes trivial to create the result below in a few steps: create a selection around the clock, move it on a transparent background, run the Droste filter, et voilà!. Equirectangular to nadir-zenith transformation The filter Deformations / Equirectangular to nadir-zenith is another filter converted from Mathmap to G’MIC. It is specifically used for the processing of panoramas: it reconstructs both the Zenith and the Nadir regions of a panorama so that they can be easily modified (for instance to reconstruct missing parts), before being reprojected back into the input panorama. Morgan Hardwood has wrote a quite detailled tutorial, here on pixls.us, about the reconstruction of missing parts in the Zenith/Nadir of an equirectangular panorama. Check it out! Other various improvements Finally, here are other highlights about the G’MIC project: • Filter Rendering / Kitaoka Spin Illusion is another Mathmap filter converted to G’MIC by Martin “Souphead”. It generates a certain kind of optical illusions as shown below (close your eyes if you are epileptic!) • Filter Colors / Color blindness transforms the colors of an image to simulate different types of color blindness. This can be very helpful to check the accessibility of a web site or a graphical document for colorblind people. The color transformations used here are the same as defined on Coblis, a website that proposes to apply this kind of simulation online. The G’MIC filter gives strictly identical results, but it ease the batch processing of several images at once. • Since a few years now, G’MIC has its own parser of mathematical expression, a really convenient module to perform complex calculations when applying image filters This core feature gets new functionalities: the ability to manage variables that can be complex, vector or matrix-valued, but also the creation of user-defined mathematical functions. For instance, the classical rendering of the Mandelbrot fractal set (done by estimating the divergence of a sequence of complex numbers) can be implemented like this, directly on the command line: $ gmic 512,512,1,1,"c = 2.4*[x/w,y/h] - [1.8,1.2]; z = [0,0]; for (iter = 0, cabs(z)<=2 && ++iter<256, z = z**z + c); 6*iter" -map 7,2


This clearly enlarge the math evaluator ability, as you are not limited to scalar variables anymore. You can now create complex filters which are able to solve linear systems or compute eigenvalues/eigenvectors, and this, for each pixel of an input image. It’s a bit like having a micro-(micro!)-Octave inside G’MIC. Note that the Brushify filter described earlier uses these new features extensively. It’s also interesting to know that the G’MIC math expression evaluator has its own JIT compiler to achieve a fast evaluation of expressions when applied on thousands of image values simultaneously.

• Another great contribution has been proposed by Tobias Fleischer, with the creation of a new C API to invoke the functions of the libgmic library (which is the library containing all the G’MIC features, initially available through a C++ API only). As the C ABI is standardized (unlike C++), this basically means G’MIC can be interfaced more easily with languages other than C++. In the future, we can imagine the development of G’MIC APIs for languages such as Python for instance. Tobias is currently using this new C API to develop G’MIC-based plug-ins compatible with the OpenFX standard. Those plug-ins should be usable indifferently in video editing software such as After effects, Sony Vegas Pro or Natron. This is still an on-going work though.
• You can find out G’MIC filters also in the opensource nonlinear video editor Flowblade, thanks to the hard work of Janne Liljeblad (Flowblade project leader). Here again, the goal is to allow the application of G’MIC effects and filters directly on image sequences, mainly for artistic purposes (as shown in this video or this one).

What’s next ?

As you see, the G’MIC project is doing well, with an active development and cool new features added months after months. You can find and use interfaces to G’MIC in more and more opensource software, as GIMP, Krita, Blender, Photoflow, Flowblade, Veejay, EKD and Natron in a near future (at least we hope so!).

At the same time, we can see more and more external resources available for G’MIC : tutorials, blog articles (here, here, here,…), or demonstration videos (here, here, here, here,…). This shows the project becoming more useful to users of opensource software for graphics and photography.

The development of version 1.7.2 already hit the ground running, so stay tuned and visit the official G’MIC forum on pixls.us to get more info about the project developement and get answers to your questions. Meanwhile, feel the power of free software for image processing!

May 17, 2016

ഒരു ചെറിയ സിനിമ, വ്യക്തമായ രാഷ്ട്രീയം, കാര്യത്തെ കൃത്യമായ തോതിൽ വൃത്തിയായി പറഞ്ഞ് പോവാൻ സനലിനു സാധിക്കുന്നു. സ്ഥിരം സിനിമകളിൽ നിന്നും മാറി ഏറെ ഡ്യൂറേഷനുള്ള ഷോട്ടുകൾ, അതും നേരത്തെ എഴുതി ചിട്ടയാക്കിയ സംഭാഷണമില്ലാത്ത നറേഷൻ ഗംഭീരമാണ്. കള്ള് കുടിച്ച് കൈവിട്ട് രാഷ്ട്രീയം പറഞ്ഞ് ഒടക്കിപോവുന്ന രംഗത്തിൽ എല്ലാ അഭിനയതാക്കളൂടേയും പ്രകടനം ഏറെ ശ്രദ്ധേയമാണ്. ഉണ്ണി ആറിന്റെ കഥയെ നീട്ടി വലിക്കുകയല്ല, മറിച്ച് കൃത്യമായ രീതിയിൽ സിനിമക്ക് ചേരുന്ന ഒരു എലമെന്റ് ആക്കി മാറ്റാൻ സനലിനു സാധിക്കുന്നു. […]
കണ്ടിരിക്കാവുന്ന ഒരു സയൻസ് ഫിക്ഷൻ. ആദ്യ ചില സെൻസ് ഫിക്ഷൻ ഭാഗങ്ങൾ കൈ വിട്ട് പോവുന്നുണ്ടെങ്കിലും കഥയുടെ പ്രധാന ഫോക്കസായ ‘ടൈം ട്രാവൽ’ വൃത്തിയയായി കാണിക്കാൻ സംവിധായകനു കഴിഞ്ഞു. സ്ഥിരം മാസ് ത്രില്ലറിന്റെ ട്വിസ്റ്റ് അല്ലെങ്കിൽ ട്വിസ്റ്റിനു മുകളിൽ ട്വിസ്റ്റ് എന്ന രീതി മാറി ഒരു ചെസ് ഗേമിന്റെ രീതിയിൽ കഥ കൊണ്ടുപോവുന്ന രീതി ഏറെ ഗംഭീരമാണ്. (പഴയ അരക്കള്ളൻ മുക്കാൽകള്ളൻ പോലെ) പാട്ടുകൾ അത്ര റഹ്മാനിക്ക് ഒന്നുമല്ല. പലതും പല പഴയ റഹ്മാൻ പാട്ടുകളേയും ഓർമ്മിപ്പിക്കുന്നു. […]

May 13, 2016

Quite some time ago, I was asked for a way to use the AV amplifier (which has a fair bunch of speakers connected to it) in our living-room that didn't require turning on the TV to choose a source.

I decided to try and solve this problem myself, as an exercise rather than a cost saving measure (there are good-quality Bluetooth receivers available for between 15 and 20€).

Introducing Blutella

I found this pot of Nutella in my travels (in Europe, smaller quantities are usually in a jar that looks like a mustard glass, with straight sides) and thought it would be a perfect receptacle for a CHIP, to allow streaming via Bluetooth to the amp. I wanted to make a nice how-to for you, dear reader, but best laid plans...

First, the materials:
• a CHIP
• jar of Nutella, and "Burnt umber" acrylic paint
• micro-USB to USB-A and jack 3.5mm to RCA cables
• Some white Sugru, for a nice finish around the cables
• bit of foam, a Stanley knife, a CD marker

That's around 10€ in parts (cables always seem to be expensive), not including our salvaged Nutella jar, and the CHIP itself (9$+ shipping). You'll start by painting the whole of the jar, on the inside, with the acrylic paint. Allow a couple of days to dry, it'll be quite thick. So, the plan that went awry. Turns out that the CHIP, with the cables plugged in, doesn't fit inside this 140g jar of Nutella. I also didn't make the holes exactly in the right place. The CHIP is tiny, but not small enough to rotate inside the jar without hitting the side, and the groove to screw the cap also have only one position. Anyway, I pierced two holes in the lid for the audio jack and the USB charging cable, stuffed the CHIP inside, and forced the lid on so it clipped on the jar's groove. I had nice photos with foam I cut to hold the CHIP in place, but the finish isn't quite up to my standards. I guess that means I can attempt this again with a bigger jar ;) The software After flashing the CHIP with Debian, I logged in, and launched a script which I put together to avoid either long how-tos, or errors when I tried to reproduce the setup after a firmware update and reset. The script for setting things up is in the CHIP-bluetooth-speaker repository. There are a few bugs due to drivers, and lack of integration, but this blog is the wrong place to track them, so check out the issues list. Apart from those driver problems, I found the integration between PulseAudio and BlueZ pretty impressive, though I wish there was a way for the speaker to reconnect to the phone I streamed from when turned on again, as Bluetooth speakers and headsets do, removing one step from playing back audio. മിസ്റ്റർ ബീമൻ രഘു കലക്കി.’എന്റെ പെൻസിൽ ആ പയ്യൻ ഇടുത്തു’ എന്ന് പറഞ്ഞ് അപ്പുക്കുട്ടനെ പോലെ വിതുമ്പിയിലല്ലോ! കോൺഫിഡൻസും കലക്കി! ഹാറ്റ്സ് ഓഫ്. Our kickstarter campaign has been running four days now, and we’re only 2000 euros short of being at 50% funded! Of course it’s Kickstarter, so it’s 100% or nothing, so we’ve still got work to do! In the meantime, Dmitry published an article on Geektimes and one of the comments had a tantalizing suggestion about locking the brush angles that when Wolthera, David Revoy and Raghukamath, resident artists on the Krita chat channel, saw the mockup of, they all cried, we want that! Since we could implement it without adding new strings, Dmitry took half a day off from bug fixing and added it! And David Revoy let himself be inspired by Cezanna and produced this introduction video: And then, among other things, we fixed the application icon on Windows, fixed issues with translations on Windows, fixed issues with the color picker, finished the Spriter scml export plugin, worked around some bugs in Qt that made popups and dialogs show on the wrong monitor, made sure author and title info gets saved to PNG images, fixed display artefacts when using Instant Preview, fixed the direction of the fade, distance and time brush engine sensors, fixed reading the random offset parameter in brush engines, improved custom shortcut handling and fixed some crashes. Oh, and we fixed the Krita Lime repository builds for Ubuntu 16.04, so you can replace the ancient 2.9.7 build Ubuntu provides with a shiny 2.9.11 Krita 3.0 is getting stabler all the time; a new beta will be released next week, but we feel it’s good enough that we’ve added Bleeding Edge download links to the download page, too! For your convenience, here are the links to the latest builds: Windows Shell Extension package by Alvin Wong. Just install it and Windows Explorer will start showing preview and meta information for Krita files. (Disregard any warnings by virus checkers, because this package is built with the NSIS installer maker, some virus checkers always think it’s infected, it’s not.) Windows: Unzip and run the bin/krita.exe executable! The OSX disk image still has the known issue that if OpenGL is enabled, the brush outline cursor, grids, guides and so on are not visible. We’re working on that, but don’t expect to have rewritten the canvas before 3.0 will be released. The Linux appimage:After downloading, make the appimage executable and run it. No installation is needed. For CentOS 6 and Ubuntu 12.04, a separate appimage is provided with g’mic built without OpenMP (which makes it much slower) (As usual, you can use these builds without affecting your 2.9 installation.) Let’s finish up with cute Kiki! May 09, 2016 I recently worked on creating an xdg-app bundle for GNOME Videos, aka Totem, so it would be built along with other GNOME applications, every night, and made available via the GNOME xdg-app repositories. There's some functionality that's not working yet though: • No support for optical discs • The MPRIS plugin doesn't work as we're missing dbus-python (I'm not sure that the plugin will survive anyway, it's more suited to audio players, don't worry though, it's not going to be removed until we have made changes to the sound system in GNOME) • No libva/VDPAU hardware acceleration (which would require plugins, and possibly device access of some sort) However, I created a bundle that extends the freedesktop runtime, that contains gst-libav. We'll need to figure out a way to distribute it in a way that doesn't cause problems for US hosts. As we also have a recurring problem in Fedora with rpmfusion being out of date, and I sometimes need a third-party movie player to test things out, I put together an mpv manifest, which is the only MPlayer-like with a .desktop and a GUI when launched without any command-line arguments. Finally, I put together a RetroArch bundle for research into a future project, which uncovered the lack of joystick/joypad support in the xdg-app sandbox. Hopefully, those few manifests will be useful to other application developers wanting to distribute their applications themselves. There are some other bundles being worked on, and that can be used as examples, linked to in the Wiki. Even while we’re still working on fixing the last bunch of bugs for what promises to become a great 3.0 release, we’re taking the next step! It’s time for the 2016 Krita Kickstarter! Last year, our backers funded a big performance improvement in the form of the Instant Preview feature and wickedly cool animation support, right in the core of Krita. And a bunch of stretch goals, some of which are already implemented in 3.0, some of which will come in Krita 3.1. This year, we’re focusing on two big topics: the text tool and the vector layers. Plus, there are a lot of exciting stretch goals for you to vote on! Krita’s text tool used to be shared with the rest of KOffice, later Calligra. It’s a complete word processor in a box, with bibliography, semantic markup, tables, columns and more! But not much fine typographic control and besides… It has always been a bad fit, it has never worked well! Now is the time to join us and make it possible to create an awesome text tool, one that is really suitable to what you need text for in Krita: real typographic and artistic control, support for various languages, for translations, for scripts from all over the world. One integrated text tool that is easy to use, puts you in control and can be extended over the years with new features. The second topic is vector graphics. It’s related to the text tool, since both are vector layer features. Currently, our vector graphics are defined in the OpenDocument Graphics format, which is fine for office applications, but not great for artwork. There’s already a start for supporting the SVG standard instead, and now’s the time to finish the job! And once we’re SVG to the core, we can start improving the usability of the vector tools themselves, which also suffer from having been designed to work in a word processor, spreadsheet or presentation application. Now that Krita is no longer part of a suite of office applications, we can really focus on making all the tools suitable for artists! Let’s make working with vector art great! And of course, there are a bunch of stretch goals, ranging from small ones to a really big stretch goal, Python scripting. Check out the kickstarter page for a full list! One of the fun parts of backing a kickstarter project are the rewards. For a Krita kickstarter, these are mostly small, fun things to remember a great campaign by. But we’re trying to do something special this year! After the kickstarter is funded, we will commission Krita artists from all over the world to create art for us that we will use in various rewards! Could you tell us something about yourself? Sure, I am originally from the UK but now live in New Zealand. At 44 I have been drawing and illustrating for over 20 years but currently only for myself. I have a love of comics and graphic novels which is pretty much the style I have inherited over the years. By day I’m a Front End Developer and by night I like to let my mind run riot and then draw it. Do you paint professionally, as a hobby artist, or both? At the moment it’s a life long hobby for me although every now and then I’ll take on the odd commission for some one who wants to own one of my style pieces. I have a long term graphic novel that I’ve been working on for a few years now, maybe when that is done that will be the professional turning point? What genre(s) do you work in? I mostly illustrate in a comic book style, pretty much all my digital paintings are figurative in some sort of way. Whose work inspires you most — who are your role models as an artist? That’s an easy one for me, it has to be Simon Bisley and Frank Frazetta. Simon Bisley’s work is legendary in the comic/graphic novel world, he really pushes the boundaries and is a complete master of his medium. As for Frank Frazetta’s work, need I say more? How and when did you get to try digital painting for the first time? The first time I did anything digital art related in a computer would be in 1991 whilst at college. They had a paint program that used the mouse and keyboard, very basic but at that time it was amazing that you could draw pictures in a computer. I used a graphics tablet to try drawing with for the first time in around 2002 but I guess the first time I properly did a complete digital painting using a tablet would have been in 2007. I saw a small 8 inch tablet in my local supermarket (yep, they sold a small range of home office equipment) and bought it to try it out. I’ve never looked back since. What makes you choose digital over traditional painting? I still love traditional painting and still do it every now and then but with digital, the scope for colours, details, speed and of course good ol’ ctrl Z means you can really go for it. That and it’s a lot less messy! I mean having a room full of canvases and somewhere to actually paint in large scale is great but just not possible these days. Once I discovered digital on a level that meant I could create what was in my head at a speed that I wanted to, then the transition was easy for me. How did you find out about Krita? I used Painter and Photoshop for Windows for years, although I always felt a little let down by them. Then I changed over to the open source movement (Linux) a couple of years ago. This meant having to find another program to paint with. I went looking in Google and read through forums for an alternative that was dedicated to digital painting with a strong emphasis on keeping it as close to traditional painting as possible. Krita was one that kept popping up and had an enthusiastic following which I really liked. What was your first impression? Shortly after I installed it I remember thinking ‘this seems to be kinda like painting a traditional picture but on steroids’. It was just so easy to use for the first time and I could see that it would suit my style very quickly. What do you love about Krita? I guess if it has to be one thing, it’s got to the the brush engines. They are by far the best I have used in painting software. Very adaptable, easy to edit and make new ones, a real joy to mess around with. Oh and the transform tool… Oh and the right click docker… Oh and the… What do you think needs improvement in Krita? Is there anything that really annoys you? There is always room for improvement and I guess everyone uses Krita in different ways. I only use Krita to paint, so for me I would like to see more improvements in the brush engines to really nail how they work across large brushes, to multiple headed brushes. One of the main things that annoys me is the brush lag when they are large but I see that’s up for being fixed for V3. Nothing really bothers me that much whilst using it. What sets Krita apart from the other tools that you use? You can really get a feel of live painting when you use it. It’s almost like you expect to have paint on your fingers when you are finished. If you had to pick one favourite of all your work done in Krita so far, what would it be, and why? This. It changes but at the moment this Terminator graphic novel style cover is my favourite. As I did it as a black and white ink drawing in Krita first, then coloured a year later. What techniques and brushes did you use in it? I still use the same techniques as I do when I paint with brushes and tubes of paint but of course the process is much faster. I started with a pencil sketch then inked it into a black and white finished piece, then coloured it later on. I used a 2b pencil brush and the ink 25 brush for the initial black and white. Then mostly 3 different wet bristle brushes for almost all of the main, titles and background tweaking them a little in the process Then some splatter brushes in the background to keep it a little messy. I keep to minimum layers only using one for the background, title and main part and sometimes just one depending on how it’s going. I have a set of about 15 brushes that I have tagged into a set as my defaults, most of them have been tweaked in some sort of way. Where can people see more of your work? The usual suspects on social sites. I mostly post finished pieces here https://www.facebook.com/tobywillsmerillustrator and I tend to post more random stuff here doodles/sketches, WIPs and the token pictures of my dog. https://www.instagram.com/tobywillsmer/ Anything else you’d like to share? I hope people enjoyed reading this and will enjoy the illustrations I keep putting out. It will be interesting to see how Krita evolves over the next few years and to see how new people finding it will adapt and use it to create and push the digital art format. I for one am looking forward to the V3 release. May 08, 2016 I recently let Firefox upgrade itself to 46.0.1, and suddenly I couldn't type anything any more. The emacs/readline editing bindings, which I use probably thousands of times a day, no longer worked. So every time I typed a Ctrl-H to delete the previous character, or Ctrl-B to move back one character, a sidebar popped up. When I typed Ctrl-W to delete the last word, it closed the tab. Ctrl-U, to erase the contents of the urlbar, opened a new View Source tab, while Ctrl-N, to go to the next line, opened a new window. Argh! (I know that people who don't use these bindings are rolling their eyes and wondering "What's the big deal?" But if you're a touch typist, once you've gotten used to being able to edit text without moving your hands from the home position, it's hard to imagine why everyone else seems content with key bindings that require you to move your hands and eyes way over to keys like Backspace or Home/End that aren't even in the same position on every keyboard. I map CapsLock to Ctrl for the same reason, since my hands are too small to hit the PC-positioned Ctrl key without moving my whole hand. Ctrl was to the left of the "A" key on nearly all computer keyboards until IBM's 1986 "101 Enhanced Keyboard", and it made a lot more sense than IBM's redesign since few people use Caps Lock very often.) I found a bug filed on the broken bindings, and lots of people commenting online, but it wasn't until I found out that Firefox 46 had switched to GTK3 that I understood had actually happened. And adding gtk3 to my web searches finally put me on the track to finding the solution, after trying several other supposed fixes that weren't. Here's what actually worked: edit ~/.config/gtk-3.0/settings.ini and add, inside the [Settings] section, this line: gtk-key-theme-name = Emacs  I think that's all that was needed. But in case that doesn't do it, here's something I had already tried, unsuccessfully, and it's possible that you actually need it in addition to the settings.ini change (I don't know how to undo magic Gnome settings so I can't test it): gsettings set org.gnome.desktop.interface gtk-key-theme "Emacs"  May 06, 2016 we're proud to announce the fourth bugfix release for the 2.0 series of darktable, 2.0.4! the github release is here: https://github.com/darktable-org/darktable/releases/tag/release-2.0.4. as always, please don't use the autogenerated tarball provided by github, but only our tar.xz. the checksum is: $ sha256sum darktable-2.0.4.tar.xz
80e448622ff060bca1d64bf6151c27de34dea8fe6b7ddb708e1e3526a5961e62  darktable-2.0.4.tar.xz


and the changelog as compared to 2.0.3 can be found below.

New Features

• Support grayscale input profiles
• Add a BRG profile for testing purposes

Bugfixes

• Fix the GUI with GTK 3.20
• Fix the color profiles we ship
• Fix two deflicker (exposure iop, mode = automatic) issues
• Fix trashing of files on OSX
• Fix Rights field in Lua

• Nikon D5
• Sony ILCA-68

•  Pentax K-S1
• Sony ILCA-68

Noise Profiles

• Canon PowerShot G15
• Fujifilm X70
• Olympus PEN-F
• Panasonic DMC-GF7

• Slovenian

• Catalan
• Dutch
• German
• Hebrew
• Slovak
• Spanish

May 05, 2016

First, let me thank all the people that donated to Inkscape’s SVG Standards Work fund as well as to the Inkscape general fund that made my attendance possible.

The subset of the SVG working group met in London after the LGM meeting to get down to the nitty gritty of getting the SVG 2 specification ready to move to the “Candidate Recommendation” (CR) stage. Three of the core group members (Nikos, Amelia, and myself) were joined some of the days by three other group members who do not normally participate in the weekly teleconferences. This was a great chance to get some new eyes looking at the spec.

Most of the time was spent in reading the specification together. We managed to get through about half the chapters including the most problematic ones. When we found problems we either made changes on the fly if possible or filed issues if not. We recently switched to Github to keep track of issues which seems to be working well. You can see outstanding issues at our issue tracker. (Feel completely free to add your own comments!)

Minutes of the meetings can be found at:

As this was a meeting focused on getting the spec out the door, our discussions were pretty mundane. Nevertheless, let me give you a flavor of the kinds of things we addressed. It was brought up in the issue tracker that the specification is unclear on how text should be rendered if it follows a <textPath> element. It never occurred to me (and probably to most people) that you could have in an SVG file the following:

<text x="50" y="150">Before<textPath xlink:href="#path">On Path</textPath>After</text>
]]>


For an implementer, it is fairly straight forward to figure out where to position the “Before” (use the ‘x’ and ‘y’ attributes) and the “On Path” (use the path) but where should the “After” be rendered? Firefox won’t render it at all. Chrome will render the “After” starting at the end position of the ‘h’ in “On Path”. After some discussion we decided that the only really logical place to render the “After” was at the end of the path. This is the only point that is well defined (the ‘h’ can move around depending on the font used to render the text).

We will have another editor’s meeting in June in Amsterdam where hopefully we’ll finish the editting so we can move the spec to CR. We’ll then need to turn our attention to writing tests. Please consider making a donation to support my travel to this meeting at the link at the start of the post! Thanks.

Short version

dnf copr enable hadess/emojidnf update cairodnf install eosrei-emojione-fonts

Long version

A little while ago, I was reading this article, called "Emoji: how do you get from U+1F355 to 🍕?", which said, and I reluctantly quote: "[...] and I don’t know what Linux does, but it’s probably black and white and who cares [...]".

Well. I care. And you probably do as well if your pizza slice above is black and white.

So I set out to check on the status of Behdad Esfahbod (or just "Behdad" as we know him)'s patches to add colour font support to cairo, which he presented at GUADEC in Strasbourg Gothenburg. It adds support for the "bitmap in font" as Android does, and as freetype supports.

It kind of worked, and Matthias Clasen reworked the patches a few times, completing the support. This is probably not the code that will be worked on and will land in cairo, but it's a good enough base for people interested in contributing to use.

After that, we needed something to display using that feature. We ended up using the same font recommended in this article, the Emoji One font.

There's still plenty to be done to support emojis, even after the cairo support is merged. We'd need a way to input emojis (maybe Lalo Martins is listening), and support in a lot of toolkits other than GNOME (Firefox only supports the SVG-in-OTF format, WebKit, Chrome, LibreOffice don't seem to know about colour fonts either).

Update: Behdad's presentation was in Gothenburg, not Strasbourg. You can also see the video on YouTube.
ഇക്കണക്കിനു ഫേസ്ബുക്കിൽ ഒരു പോസ്റ്റ്ടണം എന്ന് തോന്നിയാ നികേഷ് ഫേസ്ബുക്കിന്റെ ഹെഡ് ക്വാർടേർസിലോട്ട് പോവുമോ ? ‪#‎ഓവറാക്കിചളമാക്കാതടൈ‬
I've written an article about the surprising way the credit card industry is forcing Internet Explorer 10 out of use.

There are new development builds ready, with a bunch of bug fixes since the last beta. Please test thoroughly, we’re getting really close to the second beta! These builds have the following fixes:

• The Settings and Windows menu actions now can have shortcuts assigned to them
• Loading of images with group layers and layers in different colorspaces now always works correctly
• Several issues with onion skinning are fixed
• Make it possible again to load KPP (paintop presets) as images
• Don’t leave the pan tool when accidentally double clicking
• Fix a crash when closing Krita if the canvas mirror option is active
• Fix layouts in the advanced color selector configuration dialog
• Fix saving shortcuts
• Fix the duplicate F4 shortcut
• Fix the order of application of color curves in the Curves filter (first per-channel, then composite rgb curve, then lightness curve)
• Fix saving and loading of the image resolution in non-US locales
• Fix updating the global selection mask
• Fix the file dialog on some Linux distributions where most image types were not shown
• Show the webp image type in the file dialog
• Fix initialization of the Tool Options docker
• Fix using the canvas extension buttons with a tablet stylus
• Fix jumping of the mirror axis handle
• Make imagepipe and spray brush compatible with Instant Preview
• Fix crashes in the text tool when changing font properties
• Make it possible to use autospacing with Instant Preview
• Fix infinite loop when using the vector gradient tool
• Fix extreme slowness in the color selector
• Fix showing the page preview in the PDF export dialog
• Fix using shortcuts when the cursor is not over the canvas
• Fix the location of translations on Window

UPDATE 05.05.16: Now there in also a Windows Shell Extension package available! Just install it and Windows Explorer will start showing preview and meta information for Krita files

Windows: Unzip and run the bin/krita.exe executable!

The OSX disk image still has the known issue that if OpenGL is enabled, the brush outline cursor, grids, guides and so on are not visible. We’re working on that, but don’t expect to have rewritten the canvas before 3.0 will be released.

The Linux appimage:After downloading, make the appimage executable and run it. No installation is needed. For CentOS 6 and Ubuntu 12.04, a separate appimage is provided with g’mic built without OpenMP (which makes it much slower)

May 04, 2016

“ക്ഷേത്രാങ്കണത്തില്‍ വരാനും ഭക്തജനങ്ങളോട് വോട്ട് ചോദിക്കാനും കരിഭൂതത്തിന്റെ നിറമുള്ള മണിക്ക് എന്തവകാശം?” എന്നാണ് വെള്ളാപ്പള്ളി വചനം. കറുത്ത നിറമുള്ളവന്റെ അവകാശത്തെ ചോദ്യം ചെയ്യുന്നത് പിന്നോക്ക ഭൂരിപക്ഷത്തിന്റെ മാർപ്പാപയാണ്. ഭേഷ്! തനി നിറം, അല്ലാതെന്ത് പറയാൻ!

By: Yaroslav Kemnits, Ph.D., Creative VFX director, Division LLC, Moscow, Russia

Hardcore Henry is a sci-fi movie. The hero is a cyborg fighting other hostile cyborgs. Instead of putting it in futuristic setting, writer/director Ilya Nayshuller puts the events in the present ordinary world. That’s why the shooting has taken place in buildings and streets of a real city. Just one scene of the movie couldn’t be produced this way; the life pod free fall from stratosphere on the road near Moscow City, which should be looking like common GoPro action recording.

The fall has been filmed in three different parts: sky (above clouds), clouds (inside) and above city. The first part is set with blue sky above and white clouds canvas below – such scenes are always pretty. Then the pod enters the clouds. The GoPro shooting of falling through the clouds looks quite boring – grey screen is the only thing you see. That’s why I added turbulence effect on entering the cloud mass and made huge cave-like hollows inside. Finally, the pod flies out of clouds and we can see quickly approaching city. Hero opens the parachute which softens the impact of collision with track.

I often use Blender when I create visual effects. I use it to create action scenes animatics, to make decoration sketches and many more. And, obviously, I know about its Cloud Generator add-on, so I used it in this movie. It is simple to use and versatile at the same time.

Using it, I’ve made a cloud and dropped 6-camera unit on it. This unit is descending closer to the border of the cloud because the hero never looks backwards.

Animation of 6-camera unit

The scene was illuminated by two sources of light – Sun and Hemi (sky). I have compared render result with real GoPro recordings and it has exceeded all my expectations.

Render result

We have filmed the city with 360 degrees shooting using drone with 6-GoPro box. It was simpler.

I have synchronized the records and layed it on the cube.

The highest building in the Moscow City complex is 374 meters tall. The drone couldn’t ascend higher than that, and I have needed to make the feeling of much greater height.

I have used camera mapping in order to do this.

We have created a “white room” with programmed luminaires around the pod.

Several light FX were created with it. Moving sun light on heroine’s face during pod’s rotation, for example.

The program allowed us to alter light parameters inside and out of clouds and many other things.

Usage of mirrors enabled recording of reflections.

Finally, I’ve needed to create and animate a parachute.

It wasn’t difficult because the parachute should have been visible just for one second. I’ve used usual Round Canopy Parachute. One thing – I had to enlarge it a little, otherwise it was becoming too small. I used the cloth simulation and the wind as force for animation parachute.

We have also used Blender Fracture Modifier (http://df-vfx.de/fracturemodifier/) to create explosions and collapses.

Why have we chosen Blender?

It is a very flexible tool. It includes almost every modern top technologies and has convenient and user-friendly interface, which gives us the opportunity to solve creative problems without struggling with fiddly software.

http://www.di.vision/

Yaroslav Kemnits, Ph.D., Creative VFX director, Division LLC, Moscow, Russia

On set VFX supervisor of “Hardcore Henry” movie

Esse projeto foi pensado para contribuir com a nova política de humanização do SUS. Nessa visão, a Unidade básica de Saúde (UBS) é um local de acolhimento e aconselhamento, sendo muito mais um local onde se cuida do que...

May 03, 2016

എല്ലാ ദിവസവും പ്രാതലിന്റെ നേരത്ത് ഡബിൾ ശ്രീക്ക് ഒന്നാന്തരം ആവി പറുന്ന പുട്ടുമായി Thorbjoern Jagland വരും. അത് സന്തോഷത്തോടെ ആർത്തിയോടെ കഴിക്കുന്ന ഡബിൾ ശ്രീയെ നോക്കി അണ്ണൻ ചോദിക്കും. “ചായ…?” “ഉം. ആവാം” “ചെറുപഴം?” “ഉം. രണ്ടെണ്ണം.” “ഒരു കുറ്റി നോബൽ പ്രൈസ്” (ഉത്തരമില്ല) “ശ്രീസാർ, ഒരു കഷ്ണം നോബൽ പ്രൈസ് എങ്ങിലു…” “വേണ്ടാ” “പഴത്തിന്റെ ഒപ്പം കഴിക്കാൻ” “വേണ്ടാ!!” ഇങ്ങനെ എന്തൊക്കെ അദ്ദേഹം വേണ്ടെന്ന് വച്ചിരിക്കുന്നു. ആ ത്യാഗമൊന്നും കാണാതെ അറിയാതെ യമുനാ നദിയിൽ […]
“നിങ്ങളൂടെ ഭാര്യ/കാമുകി/അമ്മ/പെങ്ങൾ/മകൾ -ക്കാണ് ഇത് സംഭവിച്ചതെങ്കിൽ” എന്നും പറഞ്ഞ് കൊടിപിടിക്കുന്നവരൊട്, എന്താണ് സാറിത്? അവർക്കല്ലാ ഇത് സംഭവിക്കുന്നതെങ്കിൽ നീതിയും ന്യായവും വേണ്ടേ? ഇത്ര ചെറുതായി ലോകത്തെ കാണല്ലേ!
<abbr title="U+0008">�</abbr>ജിഷയ്ക്ക് നീതി കിട്ടാൻ വേണ്ടി ചെയ്യാവുന്ന എറ്റവും മണ്ടൻ പരിപാടിയാണ് ‘ഐ ബൊയ്‌ക്കോട്ട് മൈ വോട്ട്’ എന്ന ക്യാമ്പെയ്ൻ. 99% ജനങ്ങളും വോട്ട് ചെയ്യാൻ പോവാതെ ഇരുന്നാലും ഇലക്ഷനിൽ ഒരു വിജയി ഉണ്ടാവും, അയാൾ നൂറു ശതമാനത്തിന്റെയും ശബ്ദവും പ്രതിനിധിയും ആവും. ഇതിനെ ഗാന്ധിയൻ മാർഗ്ഗം എന്ന് വിശേഷിപ്പിച്ചവനോട് : <abbr title="U+0008">�</abbr>ഗാന്ധിജി പ്രതിഷേധിച്ചത് സത്യാഗ്രഹം കിടന്നാണ്. ആത്മഹത്യ ചെയ്തിട്ടല്ല.

May 02, 2016

Nathan speaking:

9 new Krita tutorials came out since the last time I made a news post here. And so did my shoulder. Out of its socket. Ouch!

But that’s a whole other story. If I’m here today, it’s to bring you 2 pieces of good news:

1. You may have noticed that the videos that came out on the channel until last week were just an introduction to the course. From now on, the vast majority of the tutorials that are coming out on the GDquest channel will be dedicated to Krita’s tools.

2. There is now a dedicated course page where you can find all of the Krita tutorials. This is also where you will find all of the extra course material that goes along with the training: exercises, cheat sheets, exclusive tips! You can find it at this address: http://gdquest.com/game-art-quest/volume-1/course-public/
Be sure to bookmark the page! I will add exclusive content over time.

Here are some of the latest videos so you can get a sense of what came out lately:

Painting with the freehand brush tool

Navigation on the canvas in Krita

Bonus: Overview of Pureref

Pureref is a powerful free application for Windows, Mac and Linux. It allows you to overlay reference pictures on top of Krita and to arrange them freely. This is a great companion for any artist out there, whether you’re an illustrator or you work in games.

Nathan

April 30, 2016

ബാത്ത്റൂമിലെ‌ പൈപ്പിൽ വരുന്ന വെള്ളം ബക്കറ്റിൽ പിടിച്ച് ഒരു മണിക്കൂർ ‘ആറാൻ’ വെയ്ക്കണം. അതാണവസ്ഥ. വാട്ട് എ റോക്കിങ് സിറ്റി!

Post Libre Graphics Meeting

What a trip!

What a blast!

This trip report is long overdue, but I wanted to process some of my images to share with everyone before I posted.

It had been a couple of years since I had an opportunity to travel and meet with the GIMP team again (Leipzig was awesome) so I was really looking forward to this trip. I missed the opportunity to head up to the great white North for last years meeting in Toronto.

London Calling

I was going to attend the pre-LGM photowalk again this year so this time I decided to pack some bigger off-camera lighting modifiers for everyone to play with. Here’s a neat travelling photographer pro-tip: most airlines will let you carry on an umbrella as a “freebie” item. They just don’t specify that it has to be an umbrella to keep the rain off you. So I carried on my big Photek Softlighter II (luckily my light stands fit in my checked luggage). Just be sure not to leave it behind somewhere (which I was paranoid about for most of my trip). Luckily I was only changing planes in Atlanta.

A couple of (bad) movies and hours later I was in Heathrow. I figured it wouldn’t be much trouble getting through border control.

I may have been a little optimistic about that.

The Border Force agent was quite nice and super inquisitive. So much so that I actually began to worry at some point (I think I must have spent almost 20 minutes talking to her) that she might not let me in!

She kept asking what I was coming to London for and I kept trying to explain to her what a “Libre Graphics Meeting“ was. This was almost a tragic comedy. The idea of Free Software did not seem to compute to her and I was sorry I had even made the passing mention. Her attention then turned to my umbrella and photography. What was I there to photograph? Who? Why? (Come to think of it, I should start asking myself those same questions more often… It was an existential visit to the border control.)

In the end I think she got bored with my answers and figured that I was far too awkward to be a threat to anything. Which pretty much sums up my entire college dating life.

Photowalk

In what I hope will become a tradition we had our photowalk the day before LGM officially kicked off and we could not have asked for a better day of weather! It was partly cloudy and just gorgeous (pretty much the complete opposite to what I was expecting for London weather).

Furtherfield Commons

I want to thank Ruth Catlow (http://ruthcatlow.net/) for allowing us to use the awesome space at Furtherfield Commons in Finsbury Park as a base for our photowalk! They were amazingly accommodating and we had a wonderful time chatting in general about art and what they were up to at the gallery and space.

They have some really neat things going on at the gallery and space so be sure to check them out if you can!

Going for a Walk with Friends

This is one of my favorite things about being able to attend LGM. I get to take a stroll and talk about photography with friends that I only usually get to interact with through an IRC window. I also feel like I can finally contribute something back to these awesome people that provide software I use every day.

We meandered through the park and chatted a bit about various things. Simon had brought along his external flash and wanted to play with off-camera lighting. So we convinced Liam to stand in front of a tree for us and Simon ended up taking one of my favorite images from the entire trip. This was Liam standing in front of the tree under the shade with me holding the flash slightly above him and to the camera right.

We even managed to run into Barrie Minney while on our way back to the Commons building. Aryeom and I started talking a little bit while walking when we crossed paths with some locals hanging out in the park. One man in particular was quite outgoing and let Aryeom take his photo, leading to another fun image!

Upon returning to the Commons building we experimented with some of the pretty window light coming into the building along with some black panels and a model (Mairi). This was quite fun as we were experimenting with various setups for the black panels and speedlights. Everyone had a chance to try some shots out and to direct Mairi (who was super patient and accommodating while we played).

Towards the end of our day I decided get my big Softlighter out and to try a few things in the lane outside the Commons building. Luckily Michael Schumacher grabbed an image of us while we were testing some shots with Mairi outside.

I loved the lane receding in the background and thought it might make for some fun images of Mairi. I had two YN-560 flashes in the Softlighter both firing around ¾ power. I had to balance the ambient sky with the softlighter so needed the extra power of a second flash (it also helps to keep the cycle times down).

The day was awesome and I really enjoyed being able to just hang out with everyone and take some neat photos. The evening at the pub was pretty great also (I got to hang out with Barrie and his friend and have a couple of pints - thanks again Barrie!).

LGM

It never fails to amaze me how every year the LGM organizers manage to put together such a great meeting for everyone. The venue was great and the people were just fantastic at the University of Westminster.

The opening “State of the Libre Graphics“ presentation was done by our (the GIMP teams) very own João Bueno who did a fantastic job! João will also be the local organizer for the 2017 LGM in Rio.

Thanks to contributions from community members Kees Guequierre, Jonas Wagner, and Philipp Haegi I had some great images to use for the PIXLS.US community slides for the “State of the Libre Graphics“. If anyone is curious, here is what I submitted:

These slides can be found on our Github PIXLS.US Presentations page (along with all of our other presentations that relate to PIXLS.US and promoting the community).

Speaking of presentations…

Presentation

I was given some time to talk about and present our community to everyone at the meeting. (See embedded slides below):

I started by looking at what my primary motivation was to begin the site and what the state of free software photography was like at that time (or not like). Mainly that the majority of resources online for photographers that were high quality (and focused on high-quality results) were usually aimed at proprietary software users. Worse still, in some cases these websites locked away their best tutorials and learning content behind paywalls and subscriptions. I finished by looking at what was done to build this site and forum as a community for everyone to learn and share with each other freely.

I think the presentation went well and people seemed to be interested in what we were doing! Nate Willis even published an article about the presentation at LWN.net, “Refactoring the open-source photography community”:

Exhibition

A nice change this year was the inclusion of an exhibition space to display works by LGM members and artists. We even got an opportunity to hang a couple of prints (for some reason they really wanted my quad-print of pippin). I was particularly happy that we were able to print and display the Green Tiger Beetle by community member Kees Guequierre:

Portraits

In Leipzig I thought it would be nice to offer portraits/headshots of folks that attended the meeting. I think it’s a great opportunity to get a (hopefully) nice photograph that people can use in social media, avatars, websites, etc. Here’s a sample of portraits from LGM2014 of the GIMP team that sat for me:

In 2014 I was lucky that houz had brought along an umbrella and stand to use, so this time I figured it was only fair that I bring along some gear myself. I had the Softlighter setup on the last couple of days for anyone that was interested in sitting for us. I say us because Marek Kubica (@Leonidas) from the community was right there to shoot with me along with the very famous @Ofnuts (well - famous to me - I’ve lost count of the neat things I’ve picked up from his advice)! Marek took quite a few portraits and managed the subjects very well - he was conversational, engaged, and managed to get some great personality from them.

A couple of samples from the images that I got are here as well, and they are the local organizer Lara with students from the University! I simply can’t thank them enough for the efforts and generosity in making us feel so welcome.

I’m still working through the portraits I took, but I’ll have them uploaded to my Flickr soon to share with everyone!

GIMPers

One of the best parts of attendance is getting to spend some time with the rest of the GIMP crew. Here’s an action shot during the GIMP meeting over lunch with a neat, glitchy schumaml:

It was great to see everyone at the flat on our last evening there as well…

Wrap up

Overall this was another incredible meeting bringing together great folks who are building and supporting Free Software and Libre Graphics. Just my kind of crowd!

I even got a chance to speak a bit with the wonderful Susan Spencer of the Valentina project and we roughed out some thoughts about getting together at some point. It turns out she lives just up the same state as me (Alabama)! This is simply too great to not take advantage of - Free Software Fashion + Photography?! That will have to be a fun story (and photos) for another day…

Keep watching the blog for some more images from the trip - up next are the portraits of everyone and some more shots of the venue and exhibition!

I haven't posted in a while. Partly I was busy preparing for, enjoying, then recovering from, a hiking trip to the Vermillion Cliffs, on the Colorado River near the Arizona/Utah border. We had no internet access there (no wi-fi at the hotel, and no data on the cellphone). But we had some great hikes, and I saw my first California Condors (they have a site where they release captive-bred birds). Photos (from the hikes, not the condors, which were too far away): Vermillion Cliffs trip.

I've also been having fun welding more critters, including a roadrunner, a puppy and a rattlesnake. I'm learning how to weld small items, like nail legs on spark plug dragonflies and scorpions, which tend to melt at the MIG welder's lowest setting.

New Mexico's weather is being charmingly erratic (which is fairly usual): we went for a hike exploring some unmapped cavate ruins, shivering in the cold wind and occasionally getting lightly snowed upon. Then the next day was a gloriously sunny hike out Deer Trap Mesa with clear long-distance views of the mountains and mesas in all directions. Today we had graupel -- someone recently introduced me to that term for what Dave and I have been calling "snail" or "how" since it's a combination of snow and hail, soft balls of hail like tiny snowballs. They turned the back yard white for ten or fifteen minutes, but then the sun came out for a bit and melted all the little snowballs.

But since it looks like much of today will be cloudy, it's a perfect day to use up that leftover pork roast and fill the house with good smells by making a batch of slow-cooker green chile posole.

April 28, 2016

Windows: Unzip and run the bin/krita.exe executable!

The OSX disk image still has the known issue that if OpenGL is enabled, the brush outline cursor, grids, guides and so on are not visible. We’re working on that, but don’t expect to have rewritten the canvas before 3.0 will be released.

The Linux appimage:After downloading, make the appimage executable and run it. No installation is needed. For CentOS 6 and Ubuntu 12.04, a separate appimage without G’Mic is provided: it is no longer possible to build the latest version of G’Mic in a way that can run on those distributions.

For my first sponsored post last month on my recently launched Patreon, I’ve decided to update the graphics of the Chess activities. There are three: End of game, Play against a friend and Play against Tux.

I think those are great to start playing chess, and not only for kids. I must say that I had a lot of fun playing with these activities while integrating the new graphics.

First, a screenshot of what it looked like before:

And now two screenshots with new graphics: the first with the new activity icons, and the second is a fullscreen view of the new chessboard and background.

I also made some style changes to the overlays while moving the pieces, and to the side text and buttons.

If you were looking for a simple chess game to play alone or with a friend, look for the next release soon, or take a look at the build instructions on the website to test the development version.

Have fun playing chess in Gcompris !

Also, I’m about to update another activity before the end of this month, so stay tuned on my patreon page for the next news, and don’t forget to subscribe if you want to support this work.

(Post in french, english version below)

Le mois dernier est sorti mon livre “Dessin et Peinture numérique avec Krita”. Il s’agit du premier livre en francais sur ce logiciel. J’espère qu’il contribuera à faire connaitre ce magnifique logiciel libre de dessin à tous les artistes francophones.

Ce livre est disponible en version imprimée couleur, en version numérique téléchargeable sans DRM ou encore en version consultable en ligne, sur le site de l’éditeur D-Booker. Je remercie d’ailleurs mon éditeur pour m’avoir permis d’écrire ce livre.

Last month, my book “Dessin et Peinture numérique avec Krita” has been released. It is the first book in french about this software. I hope it will contribute to introduce this wonderful Free Software to all french speaking artists.

This book is available in full-color printed version, as digital download without DRM or as online version, on the website of the publisher D-Booker. By the way, I’d like to thank my publisher who made it possible to write this book.

April 27, 2016

I was recently asked how to make 3rd party repositories add apps to GNOME Software. This is relevant if you run a internal private repo for employee tools, or are just kind enough to provide a 3rd party repo for Fedora or RHEL users for your free or non-free applications.

In most cases people are already running something like this to generate the repomd metadata files on a directory of RPM files:

createrepo_c --no-database --simple-md-filenames SRPMS/
createrepo_c --no-database --simple-md-filenames x86_64/


So, we need to actually generate the AppStream XML. This works by exploding any interesting .rpm files and merging together the .desktop file, the .appdata.xml file and preprocessing some icons. Only applications installing AppData files will be shown in GNOME Software, so you might need to fix before you start.

appstream-builder			\
--origin=yourcompanyname	\
--basename=appstream		\
--cache-dir=/tmp/asb-cache	\
--enable-hidpi			\
--min-icon-size=32		\
--output-dir=/tmp/asb-md	\
--packages-dir=x86_64/		\
--temp-dir=/tmp/asb-icons


This takes a second or two (or 40 minutes if you’re trying to process the entire Fedora archive…) and spits out some files to /tmp/asb-md — you probably want to change some things there to make more sense for your build server.

We then have to take the generated XML and the tarball of icons and add it to the repomd.xml master document so that GNOME Software (via PackageKit) automatically downloads the content for searching. This is as simple as doing:

modifyrepo_c				\
--no-compress			\
--simple-md-filenames		\
/tmp/asb-md/appstream.xml.gz	\
x86_64/repodata/
modifyrepo_c				\
--no-compress			\
--simple-md-filenames		\
/tmp/asb-md/appstream-icons.tar.gz	\
x86_64/repodata/


Any questions, please ask. If you’re using a COPR then all these steps are done for you automatically. If you’re using xdg-app already, then this is all magically done for you as well, and automatically downloaded by GNOME Software.

We have spent the last 20 days making over 80 fixes in Krita since the last Alpha build. We have decided it is time to enter the Beta phase! Furthermore, we’ve also spent time on improving our Windows builds.  This should fix all the scary G’Mic crashes on Windows.

Notable Fixes

• G’Mic is fixed so that it uses OpenMP for multi-threading on Linux and Windows! This is a big performance increase from Krita 2.9 which was single-threaded. G’Mic probably is still broken on OSX: no need to report that.
• Mask updating problems have been tackled rigorously!
• So have transform masks and transform bugs!
• Scary saving and loading bugs have been fixed. Remember, if you ever having a saving/loading bug with Krita, come to us immediately!
• The clone and tangent tilt brushes have fixes with crashing and behavior!
• Tons of little UI fixes with theme colors and consistency.
• Several fixes for the shortcuts. They should now be saved and loaded properly.
• Tablet fixes for dealing with animation. This makes duplicating frames easier, as well as using several tools faster.
• Several fixes in the grids and guides.
• And much more… See the full list of bug fixes!
• Linux and Windows builds now should have full access to all translations and all of the menus should be translated.

From here, we will go through another round of bug fixing. We would love it if you could test out the new build and give us feedback in the chatroom or bug reporter. This testing helps us prevent ‘surprise issues’ when Krita 3.0 will be released in the coming weeks.

Kickstarter!

We had intended to get 3.0 ready before the next kickstarter, but we feel its more important to spend another month fixing bugs. We’re still going ahead with the next Kickstarter on schedule, so the May Kickstarter will coincide with the May release of Krita 3.0!

Known Issues

We’re fixing bugs like crazy, but there are still a number of known bugs. Please help us by testing this beta release and checking whether those bugs are still valid! Bug triaging is an awesome way of becoming part of our community.

We haven’t managed to create an MSI installer next to the zip files. But we do have 32 bits builds as well as 64 builds now, and a new setup that makes it really fast and easy to do new builds. These builds also include for the first time the camera raw importer plugin and the PDF import/export plugin.

There are also Windows builds with debug information available, as an experiment from http://files.kde.org/krita/3/windows.

The OSX disk image still has the known issue that if OpenGL is enabled, the brush outline cursor, grids, guides and so on are not visible. We’re working on that, but don’t expect to have rewritten the canvas before 3.0 will be released.

The Linux appimage should run on any Linux distribution released since 2012. After downloading, make the appimage executable and run it. No installation is needed.

Source code:

Git repository:

What’s going on with Hubs?

So a little update for those not following closely to get you up to date:

• We have a big milestone we’re working towards – a working version of Fedora Hubs in time for Flock. It won’t have all of the bells and whistles of the mockups that we’ve presented, but it will be usable and hopefully demonstrate the potential of the app as well and enable more development.
• We have a number of fantastic interns coming on board (including Devyani) who will be helping us work on Fedora Hubs this summer.
• pingou is going to be leading development on fedora-hubs.
• I’m clearly back from an extended leave this past winter and cranking back on mockups again.
• ryanlerch has upgraded hubs to fedora-bootstrap so it has a fresh look and feel (which you’ll see reflected in mockups moving forward.)
• Overall, we’ve gotten more momentum than ever before with a clear goal and timeline, so you’ll hopefully be seeing a lot more of these juicy updates more frequently!

(“Wait, what is Fedora Hubs?” you ask. This older blog post has a good summary.)

Okay, so let’s move on and talk about Hubs and Badges, particularly in light of some convos we’ve had in the regular weekly Fedora Hubs check-in meetings as well as an awesome hack session Remy D. and jflory7 pulled together last Thursday night.

Fedora Hubs + Badges – what’s old is new again

Behold, a mockup from 2011:

In a sense, this is actually an early prototype/idea for Fedora Hubs + Badges integration. Remember that one of the two main goals of Fedora Hubs is to enable new Fedora users and make it easier for them to get bootstrapped into the project. Having tasks in the form of badges awarded for completing a task arranged in “missions” makes it clear and easy for new contributors to know what they can do and what they can do next to gradually build up their skills and basically ‘level up’ and feel happy, helpful, and productive. So there’s a clear alignment between badges and hubs in terms of goals.

So that was 2011, where are we going in 2016?

We have a couple of tickets relating to badges in the hubs issue tracker:

As we’ve been figuring out as we’ve been going through the needsmockup queue and building widgets, most widgets have at least two versions: the user version (what data in this widget relates to me? Across all projects, what bugs are assigned to me?) versus the project version (across all users, what bugs relate to this project?) You can’t just have one badges widget, because certain data related to that widget is more or is less useful in the context it’s being viewed in.

Today, the Fedora badges widget in Hubs is not unlike the one on the Fedora wiki (I have both the sidebar version and the content side version on my profile.) It’s basically small versions of the badge icon art in a grid (screenshot from the wiki version):

The mockup below (from issue #85) shows what a little pushing in terms of working the metadata we’ve got available can do to provide a clearer picture of the badge earner via the badges he or she has won (left version is compressed, right version is expanded):

The above mockups are all just layer 0 stuff though. Layer 0? Yeh, here’s a hokey way of explaining how we’re starting to think about hubs development, particularly in the context of getting something out the door for Flock:

• Layer 0 – stuff we already have in place in hubs, or refinements on what’s already implemented.
• Layer 1 – new feature development at a base level – no whizbang or hoozits, and absolutely nothing involving modifications to ‘upstream’ / data-providing apps. (Remember that Hubs is really a front-end on front of fedmsg… we’re working with data coming from many other applications. If a particular type or format of data isn’t available to us, we have to modify the apps putting that data on the bus to be able to get it.)
• Layer 2 – making things a bit nicer. We’re not talking base model here, we’re getting some luxury upgrades, but being pretty sensible about them. Maybe making some modifications to the provider apps.
• Layer 3 – solid gold, gimme everything! This is the way we want things, having to make modifications to other apps isn’t of concern.

To get something out the door for Flock… we have to focus mostly on layer 0 and layer 1 stuff. This is hard, though, because when this team gets together we have really awesome, big, exciting ideas and it’s hard to scale back. It’s really fun to brainstorm together and come up with those ideas too. In the name of fun, let’s talk through some of the layers we’ve been talking about for badges in hubs in particular, and through this journey introduce some of the big picture ideas we have.

An oftrequested feature of tahrir, the web app that powers badges.fedoraproject.org, is the notion of grouping badges together in a series (similar to the “missions” in the 2011 mockup above.) The badges in the series can be sequentially ordered, or they may have no particular order. Some in a series can have a sequential ordering and some not at all.

Here’s an example of badges with a sequential ordering (this series goes on beyond these, but the example three illustrate the concept well enough):

Here’s an example of badges that are closely related but have no particular sequence or order to them:

You can see, I hope, how having these formally linked together would be a boon for onboarding contributors. If you earned the first badge artist badge, for example, the page could link you to the next in the series… you could view a summary of it and come to understand you’d need to make artwork for only four more badges to get to the next level. Even if there isn’t a specific order, having a group of badges that you have to complete to get the whole group, like a field of unchecked checkboxes (or unpopped packing bubbles), kind of gives you the urge to complete them all. (Pop!) If a set of badges correspond to a set of skills needed to ramp up for work on a given project, that set would make a nice bootstrapping set that you could make a prerequisite for any new join requests to your project hub. So on and so forth.

So here’s the BIG SECRET:

How do we present badges in series without this critical piece of metadata? We use a system already in place – badge tags. Each series could have an agreed upon tag, and all badges with that tag can become a group. This won’t give us the sequential ordering that some of the badges demand, but it’ll get us a good layer 1 to start. Mockup forthcoming on this, but it will get us a nicer badge widget for project / team hubs (issue #17).

Here’s layer 2 for the feature – and I thought this would be the end of the road before Remy set us straight (more on that in the next section on layer 3):

So this one is somewhat simple. We potentially modify the badges themselves by adding additional fields to their yaml files (example behind link), and modify tahrir, the web app that drives badges.fpo, to parse and store those new fields. I tried to piece together a plan of attack for achieving this in tahrir ticket #343.

The problem here is that this would necessarily require changing the data model. It’s possible, but also a bit of a pain, and not something you want to do routinely – so this has to be done carefully.

Part of this would also involve dropping our overloading of tags. Now we can store descriptions for each badge series, and store sequential ordering for individual badges, and a few other nice things tags couldn’t enable.

If we’re changing the data model for layer 2, may as well also change it for *LAYER 3!!*, which I am emphasizing out of excitement.

Layer 3: How the years I spent playing Final Fantasy games finally pay off

“A simplified example of a skill tree structure, in this case for the usage of firearms.” Created by user Some_guy on Wikipedia; used under a CC0 license.

Remy D. suggested instead of linear and flat groupings of badges, we also add the ability to link them together into a skill tree. Now, you may already have experience with say the Final Fantasy series, Diablo series, Star Wars: The Old Republic, or other RPG-based games. Related skills are grouped together in particular zones of the tree, and depending on which zones of the tree you have filled out, you sort of fulfill a particular career path or paths. (e.g., in the case of Final Fantasy X… when you work towards filling out Lulu’s sphere grid area, you’re making your character a dark mage. When you work towards filling out Rikku’s area, you’re building skills towards become a skilled thief. So on, and so forth.)

Where this gets cool for Fedora is that we not only can help contributors get started and feeling awesome about their progress by presenting them clear sequences of badges to complete to earn a series (layer 2), but we can also help guide them towards building a ‘career’ or even multiple ‘careers’ (or ‘hats,’ heh) within the project and build their personal skill set as well. Today we already have five main categories for badges in terms of the artwork templates we use, but we can break these down further if need be – as-is, they map neatly to ‘careers’ in Fedora:

• Community
• Content
• Development
• Quality
• Events

Fedora contributors could then choose to represent themselves using a radar chart (example displayed below), and others can get a quick visual sense of that contributor’s skillset:

So that’s layer 3.

Okay, so have you actually thought about what badges should be chained together for what teams?

Yes. Remy D. and jflory7 started a list by researching the current onboarding procedures across a number of Fedora teams. Coming up with the actual arrangements of badges within series is important work too that has a big influence on whether or not the system actually works for end users! These suggestions Remy and Justin put together are suggestions of badges new contributors should complete while getting boostrapped and ready to contribute to the corresponding team.

In some cases these involve existing badges, in some cases additional badges we need to create to support the scenario have been uncovered. (This is great work, because over time badges has tended to be unbalanced in terms of awarding folks involved in packaging and who go to a lot of events more than others. It makes sense – the packaging infrastructure was the first part of Fedora’s infrastructure to get hooked up to fedmsg IIRC, so the data was more readily available.)

Here’s an excerpt of the first-cut of that work by Justin and Remy:

1. Get a FAS Account (sign the FPCA) (Involvement)
2. Create a User Wiki Page
3. Join Mailing Lists and IRC Channels
4. Contact a Regional Mentor, get sponsored
5. Get mentor approval
6. Attend regional ambassador meeting, introduce yourself
CommOps
1. If no fas account, create one (Involvement)
2. Intro to commops mailing list
3. Join IRC #fedora-commops
4. Get with a mentor and start writing / editing blog / fed mag articles
Design
1. Create a FAS account (sign the FPCA) (Involvement)
2. Join the mailing list, introduce yourself: https://admin.fedoraproject.org/mailman/listinfo/design-team
3. Claim a ticket in the Design Trac: https://fedorahosted.org/design-team/report/1
4. Update your ticket, send updated information to Design List
5. Once work is approved, request an invite for your FAS username for the design-team group on the design team list: https://admin.fedoraproject.org/mailman/listinfo/design-team
6. Add yourself to the contributors list: http://fedoraproject.org/wiki/Artwork/Contributors
7. Attend Design Team IRC meeting? (Speak Up)
8. Subscribe to the design tasks fedocal: https://fedorapeople.org/groups/schedule/f-24/
Documentation
1. Create a FAS Account (sign the FPCA) (Involvement)
2. Create a GPG Key, and upload it to keyservers, one of which being keys.fedoraproject.org (Crypto Panda)
3. Write a self-introduction to the mailing list with some ideas on how you would like to contribute: https://fedoraproject.org/wiki/Introduce_yourself_to_the_Docs_Project
4. Create your own user wiki page, or update with new info if one exists from another prject (Let me Introduce myself Badge)
5. Attend the freenode.net InterRelay Chat channel #fedora-meeting meetings on Mondays. (Speak Up Badge)
6. Hang out on freenode.net InterRelay Chat channel #fedora-docs
7. Interact with other fedora contributors (how to use fasinfo, lookup others wiki user pages, asking for sponsorship)
9. Post to mailing list, describing which contribution you want to make, asking for feedback
Marketing
1. Create a FAS Account (and sign the FPCA) (Involvement)
2. Join the mailing list and introduce yourself: https://fedoraproject.org/wiki/Introduce_yourself_to_the_marketing_group
3. Choose a marketing task you’d like to help with, and post to the mailing list asking for feedback: https://fedoraproject.org/wiki/Marketing/Schedule
4. Post to the mailing list with a link to your contribution.
5. Request to join the marketing group in FAS

Hopefully that gives a better picture on specifics, and what some of the bootstrapping series particularly would involve. You see here how a skill tree rather than badge series makes more sense – you only need create one FAS account, participate in IRC once intially, and participate on a mailing list once initially to learn how those things work before you shoudl really move on. So with this system, you could learn those “skills” joining any team, and where you complete the series for any particular team are the higher-numbered badges in that team’s bootstrap series. (Hope that makes sense.)

Help us build fun yet effective RPG-like components into a platform that can power the free software communities of the future! How do you start? Sadly, we do not have the badge series / skill tree feature done yet, so I can’t simply point you at that. But here’s what I can point you to:

• hubs-devel Mailing List – our list is powered by HyperKitty, so you don’t even need to have mail delivered to your inbox to participate! Mostly our weekly meeting minutes are posted here. I try to post summaries so you don’t have to read the whole log.
• The Fedora Hubs Repo – the code with instructions on how to build a development instance and our issue tracker which includes tickets discussed above and many more!
• Fedora Hubs weekly check-in meeting – our weekly meeting is at 14:00 UTC on Tuesdays in #fedora-hubs. Come meet us!

What do you think?

Questions? Comments? Feedback? Hit me up in the comments (except, don’t literally hit me. Because mean comments make me cry.)

April 26, 2016

Every year Google puts on a program called Google Summer of Code (GSoC). Students from all over the world try to obtain an internship where they can be paid to work on an open source application. This year we are lucky enough to have had three students accepted into the program! (Who gets accepted depends on how many applications there are, how many slots Google has and how many get distributed to KDE.) These three students will be working on Krita for the summer to improve three import areas in Krita.

Here is what they will be trying to tackle in the coming months.

1. Jouni Pentikäinen – GSoC Project Overview – “This project aims to bring Krita’s animation features to more types of layers and masks, as well as provide means to generate certain types of interpolated frames and extend the user interface to accommodate these features.” In short, Jouni is going to work on animating opacity, filter layers and maybe even transform masks. Not just that, but he’ll work on a sexy curve time-line element for controlling the interpolation!
2. Wolthera van Hövell tot Westerflier   – GSoC  Project Overview – “Currently, Krita’s architecture has all the bells and whistles for wide-gamut editing. Two big items are missing: Softproofing and a good internal colour selector dialogue for selecting colours that are outside of the sRGB colour space.” Wolthera’s work will make illustration for print workflows much smoother, letting you preview how likely your RGB image will keep at it’s details when printed out. Furthermore, she’ll work on improving your ability to use filters correctly on wide gamut files, extending Krita’s powerful color core.
3. Julian Thijsen – GSoC Project Overview –  “I aim to seek out the reliance on legacy functionality in the OpenGL engine that powers the QPainter class and to convert this functionality to work using OpenGL 3.2 Core Profile — it needs the compatibility profile at the moment. This will enable OSX to display decorations and will likely allow Krita to run on Mac OS X computers.” This one is best described as a “OpenGL canvs by-pass operation”, Krita currently uses OpenGL 2.1 and 3.0. To run on OSX, we’ll need to be able to run everything in OpenGL 3.0 at the least. It is the biggest blocker for full OSX support, and we’re really excited Nimmy decided to take the challenge!

The descriptions might sound a bit technical for a lay person, but these enhancements will make a big impact. We congratulate the accepted students and wish them the best of luck this summer.

April 25, 2016

Could you tell us something about yourself?

Hi, my name is Tomáš Marek. I’m 22 years old, self-taught digital/traditional artist and student, and I currently live in the Czech Republic. Unlike most of the other artists I started drawing pretty late, about 4 years ago, mainly because I never had any sign of a talent for anything, and I had no idea what I wanted to do with my life. It was 4 years ago when I found out about my great-grandfather who was an artist (landscape painter) which was the initial trigger for me, “I want to be an artist”. Since then I draw pretty much every day.

Right now I’m working on my personal project, it will be a graphic novel, can’t tell you much about it yet, and developing my own style which I call #BigNoses.

Do you paint professionally, as a hobby artist, or both?

In this moment I see myself more like a hobbyist than professional, because right now I’m still a student and I’m working on my degree in computer graphics, which is very time consuming. However, from time to time I do some freelance or commissions. So lets say I’m both.

What genre(s) do you work in?

I actually never thought about drawing in some specific genre, I pretty much draw what and how I feel that day.

Whose work inspires you most — who are your role models as an artist?

Well, I can’t pick just one artist, there are so many of them. But if I could pick three of them, the first would be my great-grandfather who introduced me to art, the second is Sycra Yasin who taught me that mileage is more important than talent, and the most recent one is Kim Jung Gi because, well, just look at his work and you will know why.

How and when did you get to try digital painting for the first time?

My first time was in 2012 in the house of my friend, who had a Wacom Cintiq 13. He let me try it with Photoshop CS4 and my first impression of it was “I want one”.

What makes you choose digital over traditional painting?

That would probably be freedom of tools. Because I’m the constantly changing and erasing type of guy. And with digital not only that changing stuff is fast and clean but also, as the saying goes, “pixels are cheap”.

How did you find out about Krita?

The first time I heard about Krita was about 2 years ago on Sycra’s Youtube channel, I think he drew his self-portrait. But I didn’t pay much attention to it because in that time I was using Photoshop for my paintings, which I didn’t like but it was the only software that I knew how to use.

OK, I remember this moment very well. When I first opened Krita, picked the first brush I saw, I think that it was the Color Smudge type, then I started with painting, and this is what I had in my mind: “This is weird, but kinda cool, but weird… yeah I love it”. I hope this sums it up well.

What do you love about Krita?

Mainly these almost traditional-like brush engines, and the fact that it runs on GNU/Linux, Windows and Mac OS.

What do you think needs improvement in Krita? Is there anything that really annoys you?

I would like to see a realtime histogram of all visible layers, not only for one selected layer. And some performance improvement for filters.

What sets Krita apart from the other tools that you use?

I’m a GNU/Linux user and when I wanted to paint I always had to reboot to Windows to use Photoshop for painting, so with Krita I don’t have to use Windows at all.

And as I said before, I love Krita’s brush engines.

If you had to pick one favourite of all your work done in Krita so far, what would it be, and why?

This is hard; it’s like asking parents which is their favourite child, but if I had to choose it would be probably my recent painting from my series #BigNoses called “It’s Something”

What techniques and brushes did you use in it?

For most of my work I’m using my own brush, which is a rectangle brush with pressure size and softness, plus airbrush and some texture brushes. And my technique is pretty simple pipeline: lineart → base colors → shades → rendering.

Where can people see more of your work?

I’m frequently posting my work on these sites: