Umlaute von Zotero nach BibTeX exportieren

Mag sein, dass dieser Artikel eine beinahe inexistente (Wissens-) Lücke füllt. Für all jene, denen weder BibTeX noch Zotero etwas sagt, ist er mit Sicherheit nicht lesenswert, aber allein die Möglichkeit, dass ich selbst nochmal auf das geschilderte Problem treffe, rechtfertigt ihn dennoch.

Das Problem von dem ich spreche ist der Dateiexport von Zotero, einem Programm das ich zur Verwaltung meiner Bibliographie verwende, nach BibTeX, dem Dateiformat das ich zur automatischen Erstellung der Referenzen und des Quellenverzeichnisses in meiner Dissertation verwende. Wenn nun im Titel von verwendeten Quellen oder in Namen von deren Autoren deutsche Umlaute oder diakritische Zeichen (wie z.B. französische Akzente) vorkommen, werden diese in der exportierten Datei unverändert wiedergegeben, weil Zotero die ausgegebene Datei per Vorgabe als UTF-8 kodiert. Diese Kodierung wird aber von BibTeX nicht richtig verarbeitet.

Für diese Problem gibt es zwei Lösungswege, wobei ich leider viel Zeit mit dem ersten verloren habe:

  1. Man kann versuchen, BibTeX zur richtigen Verarbeitung der UTF-8 Datei zu bringen, bzw. einen dementsprechenden Ersatz für BibTeX einzusetzen. Diesbezüglich gibt es jede Menge Diskussionen im Internet, die die Hoffnung (leider) nicht schnell genug sterben lassen. Der Vollständigkeit halber sei hier beispielhaft auf bibtex8 verwiesen.
  2. Viel einfacher ist es jedoch, Zotero dazu zu bringen, die kritischen Zeichen entsprechend der LaTeX Syntax auszugeben. Das schafft man aber nicht, indem man selbst die Einträge entsprechend ändert, sondern indem man die Dateikodierung für den Export ändert.

    Dazu muss man lediglich in den Einstellungen von Zotero in der Kategorie Export ein Häkchen bei „Option für Zeichenkodierung beim Export anzeigen“ setzen. Beim nächsten BibTeX Export ist dann einfach „Westlich (ISO-8859-1)“ aus der Liste auszuwählen und schon erstellt Zotero eine problemlos verwendbare BibTeX Datei.

Inkscape Standardvorlage

Gestern war ich wieder einmal in der Situation, dass ich eine per Hand gezeichnete Skizze in einem Dokument verwenden wollte. In solchen Faellen ist Vektorgrafik Software Inkscape für mich die erste Wahl. In Inkscape angefertigte Zeichnungen lassen lassen sich ganz natürlich im EPS Format exportieren, das wiederum erste Wahl für Grafiken in LaTeX Dokumenten ist. Bei Bedarf lassen sich EPS Dateien auch unkompliziert in PDF umwandeln und mit pdfLaTeX verwenden.

Nun muss ich jedes Mal, wenn ich eine neue Zeichnung mit Inkscape beginnen wollte, zuerst eine Reihe von Dokumenteneinstellungen ändern, weil eine A4 Seite im Hochformat und mit Pixel Angaben auf den Linealen nicht das ist, was ich brauche. Stattdessen verwende ich immer A6 im Querformat mit Millimeter Angaben und einem 1mm Gitter. Die Vermutung, dass sich die Standardeinstellungen ändern lassen, bestätigte sich anhand eines Treffers in den Inkscape FAQ.

Um es kurz zu machen: Man muss ein leeres Dokument nach den eigenen Vorstellungen erstellen und es als

~/.config/inkscape/templates/default.de.svg

speichern, wenn man, wie ich, Deutsch als Systemsprache verwendet.

Embed PDFs from Zotero

I’m using Zotero to organise my bibliography. Not only do I store citation information, but I also love the possibility to let it organise the corresponding PDF files. That way I have full-text search and a superb tagging facility for almost everything I read and might need to use and cite later. As a Fedora user, I didn’t have Firefox configured to embed all kind of media into the browser by default. In general I perceive this as an advantage, but in my use-case I have Firefox with Zotero running in full-screen on a separate workspace and want it to manage the screen entirely. And since Evince is the default PDF viewer on Gnome at the moment, I would like it to be embedded into Firefox tabs as I open PDFs from Zotero.

As quick search for the topic brought me to an article in the Ubuntu Forums which solved 90% of the problem. Installing Mozplugger

yum install mozplugger

and raising the priority of Evince as its PDF handler made most of the PDFs open embedded just as intended. However, Zotero seems to assign an unusual MIME type for the PDFs it stores that is „application/octetstream“. Thus to fit my needs, I added that type to the Mozplugger PDF handler

sudo vim /etc/mozpluggerrc

which now reads as

application/pdf:pdf:PDF file
application/x-pdf:pdf:PDF file
text/pdf:pdf:PDF file
text/x-pdf:pdf:PDF file
application/octetstream:pdf:PDF file
        repeat noisy swallow(evince) fill: evince "$file"
#       ACROREAD()
#       repeat noisy swallow(kpdf) fill: kpdf "$file"
#       repeat noisy swallow(Xpdf) fill: xpdf -g +9000+9000 "$file"
#       repeat noisy swallow(okular) fill: okular "$file"
#       GV()
#       repeat noisy fill exits: evince "$file"

Zim

Jene Linux Anwendung, die OneNote im Funktionsumfang am nächsten kommt ist vermutlich BasKet. Trotzdem schreibe ich diesen Artikel, weil ich für mich Zim als geeignetste Anwendung befunden habe. Zim wird vom Autor als „Desktop Wiki“ bezeichnet. Was die Textverarbeitung betrifft, wird damit das meiste bereits erklärt. Wer jemals einen Wiki Artikel geschrieben hat, kennt das Prinzip.

Was Zim für mich aber perfekt macht, denn es ist beileibe nicht das einzige Desktop Wiki, sind drei Plugins, die folgende Funktionen zur grundlegenden Wiki Funktionalität hinzufügen:

Wie eventuell aus dem Countdown zur Veröffentlichung von Fedora 13 im rechten Rand zu schließen war, ist momentan Linux das Desktop und Laptop Betriebssystem meiner Wahl. Ohne weiter ausholen zu wollen, möchte ich nur anmerken, dass diese Wahl nicht aus ideologischen sondern aus technischen Überlegungen resultiert. Die Hardwareanforderungen aktueller Windows Versionen haben sich zu weit von den mir zur Verfügung stehenden Tatsachen entfernt als dass ein vernünftiger Betrieb möglich wäre. Andererseits ist eine Weiterverwendung veralteter Windows Versionen mit zu vielen, nicht zuletzt sicherheitstechnischen, Nachteilen verbunden.

Die eigentliche Herausforderung, wenn man Windows gänzlich den Rücken kehren möchte, besteht kaum mehr in Inkompatibilitäten wie es scheint, sondern vor allem im Bruch mit Gewohntem. Damit meine ich nicht das Betriebssystem, denn damit hat man als Benutzer kaum Kontakt, sondern die Anwendungen. Ich kann mir gut vorstellen, dass in manchen Bereichen für Linux keine adäquaten Entsprechungen für tausende Euro teure kommerzielle Software zu finden ist. Dennoch möchte ein Beispiel für (m)einen Fall bringen, wo eine Anwendung trotz kleinerem Funktionsumfang eine andere ersetzen kann.

Zim

Eine meiner Lieblingsanwendungen unter Windows ist OneNote. Als Notiz- und Logbuch hat sich dieses Programm als sehr nützlich erwiesen. Die Hauptvorteile gegenüber einem Papierblock sind für mich die Suchfunktion, der Umgang mit Markierungen (Schlagworten) und nicht zuletzt die Möglichkeit, schnell und einfach Bildschirmausschnitte in den Text einzufügen. Da ich beinahe sämtliche Information über den Bildschirm verarbeite, ist das Speichern von Bildschirmausschnitten das allgemeinste Interface. Als Naturwissenschaftler verwende ich diese Technik sehr oft, um Diagramme, die von einem beliebigen Programm erzeugt wurden, in das elektronische Notizbuch zu „kleben“.

Jene Linux Anwendung, die OneNote im Funktionsumfang am nächsten kommt ist vermutlich BasKet. Trotzdem schreibe ich diesen Artikel, weil ich für mich Zim als geeignetste Anwendung befunden habe. Zim wird vom Autor als „Desktop Wiki“ bezeichnet. Was die Textverarbeitung betrifft, wird damit das meiste bereits erklärt. Wer jemals einen Wiki Artikel geschrieben hat, kennt das Prinzip.

Was Zim für mich aber perfekt macht, denn es ist beileibe nicht das einzige Desktop Wiki, sind drei Plugins, die folgende Funktionen zur grundlegenden Wiki Funktionalität hinzufügen:

  • Es ist möglich Schnappschüsse vom ganzen Bildschirm, einzelnen Fenstern und frei wählbaren Ausschnitten zu machen.
  • Es ist möglich, Formeln einzufügen, die man in einem separaten Dialog per LaTeX Syntax formulieren kann.
  • Eine Versionsverwaltung kann verwendet werden, um Änderungen an den Notizen zu verfolgen.

Zur absoluten Perfektion fehlen meiner Meinung nach nur zwei Features:

  • Schlagworte (Tags) – ein für die Zukunft geplantes Feature
  • Versionsverwaltung mit Git (statt Bazaar oder Subversion) – Gewohnheit

Zim in Fedora

Leider enthält Fedora, selbst in der noch nicht freigegebenen Version 13, nicht die aktuelle Version von Zim. Man findet aber in Bugzilla den Bug 563844, der neben einer aufschlussreichen Diskussion auch einen Link auf eine aktuelle SRPM enthält. Wie man daraus eine installierbare RPM baut erfährt man (neben sicherlich unzähligen anderen Stellen) im Fedora Wiki.

Lightning Problem

Ich hatte schon seit einiger Zeit ein Problem mit dem Lightning Plugin von Mozilla Thunderbird. Angefangen hat es mit dem Update auf Version 0.9. Jedes Mal wenn ich Thunderbird gestartet habe kam zweimal folgende Fehlermeldung:

An error was encountered preparing the calendar located at moz-profile-calendar:// for use. It will not be available.

Da ich die Funktionalität von Lightning nicht viel verwendet habe, entschied ich mich als schnellste „Lösung“, das Plugin zu deinstallieren.

Heute habe ich nach kurzer Recherche eine Lösung für das Problem gefunden. Sie wird im Bugzilla System von Fedora an folgender Stelle erklärt:

https://bugzilla.redhat.com/show_bug.cgi?id=542736#c5

Rekordverdächtig

Heute Nacht hat es, wie vom Wetterdienst gestern vorhergesagt, erneut geschneit. In Annemasse haben wir also mittlerweile geschätzte 30 cm Schnee vor dem Haus liegen. Für Dory ist das zwar unangenehm, stellt aber kein echtes Problem dar. Leider gilt das für den Verkehr nicht. Ich hatte heute von zuhause bis auf den CERN Parkplatz genau 2 Stunden und 21 Minuten Fahrtzeit, was eindeutig ein neuer Rekord ist. Üblicherweise benötige ich für die etwa 35 km (davon 26 km Autobahn) 40-50 Minuten wenn ich zur selben Zeit fahre wie alle anderen. Immerhin gilt es zweimal die Grenze zwischen der Schweiz und Frankreich zu überqueren. Außerhalb der Stoßzeit habe ich die Strecke auch schon in 32 Minuten geschafft.

Gegen Ende war die heutige Fahrt dann schon fast unterhaltsam. In einem der vielen Kreisverkehre hat sich das vor mir fahrende Auto um 180 Grad gedreht und stand mir frontal gegenüber.

Ich hoffe nur, dass der Nachhauseweg etwas weniger Zeit braucht.

Nachtrag

Der Rückweg war eine positive Überraschung: Ich habe meine Bestzeit von 32 Minuten wiederholt, da wundersamer Weise zwischen 17:50 und 18:22 Uhr kaum Verkehr war.

Sicherung eines Netzwerkpfades unter Windows Vista

Ich weiß, dass es für gewöhnlich umgekehrt ist, aber ich stand vor dem Problem, dass ich auf einer zentral verwalteten Maschine mit einem Benutzerkonto auf einem DFS-Server die dort abgelegten Daten gerne lokal gesichert hätte. Der Grund dafür war in erster Linie mein Misstrauen gegenüber der Verfügbarkeit der Netzwerkverbindung. Ich wollte auch an Tagen, an denen es Netzwerkprobleme gab, mit meinen Daten ungestört weiterarbeiten können (ohne mich auf die Vista-eigenen Offline Mechanismen verlassen zu müssen).

Das folgende Skript erfüllt genau diese Aufgabe und ist auch leicht per Taskplaner zu automatisieren. Um es einzusetzen, müssen nur die Einstellungen in Zeile 3 bis 6 angepasst werden und dafür gesorgt sein, dass 7-zip installiert ist.

@echo off

set source=\\cern.ch\dfs\Users\f\fmoser
set destination=D:\fmoser\Backup
set prefix=fmoser_
set szip="C:\Program Files (x86)\7-Zip\7z.exe"

For /f "tokens=1-3 delims=/ " %%a in ('date /t') do (set mydate=%%c-%%a-%%b)
For /f "tokens=1-2 delims=/:" %%a in ('time /t') do (set mytime=%%a%%b)
set backupname=%destination%\%prefix%%mydate%_%mytime%
mkdir %backupname%
robocopy %source% %backupname% /MIR /Z /R:10 /W:30 /COPY:DATSO /XJ /LOG:%backupname%.log /NP
%szip% a -t7z -mx9 %backupname%.7z %backupname% %backupname%.log && rd /S /Q %backupname% && del %backupname%.log

backup_dfs.cmd

Find overlapping polygons with Python

Yesterday I was confronted with a seemingly simple problem: how can one find out if the rectangles or, more general, polygons on a surface are overlapping or not? Surprisingly, because they have an amazing collection of tools, the matplotlib library used in this context to actually draw the rectangles, doesn’t seem to have this kind of functionality. Of course there are loads of examples on the web for 2D collision detection, but I couldn’t find one written in Python. But nevertheless, I found lecture notes on Robert Pless’s website, which taught me the quadrant method to check if one point lies inside a polygon. Then it is only a small step to find if polygons are intersecting.

After writing a Python module providing the functionality, it naturally turned out to be rather slow on big numbers of polygons to be checked. So I continued to write a function which checks which polygons in a given set are overlapping or touching. To use the resources on my machine efficiently, I made two versions of this later function: one for conservative, serial processing and a second which uses Parallel Python to distribute the workload among the CPUs found in the system.

If someone else needs this kind of functionaltiy as well or simply is interested in how I did it, here is the interesting part. The whole file with unit tests and documentation can be downloaded as well: polygons_overlapping.py

import pylab

class PolygonsTouching( Exception ):
    """ This exception is triggered when two polygons touch at one point.

    This is for internal use only and will be caught before returning.

    """
    def __init__( self, x=0, y=0 ):
        self.x, self.y = x, y
    def __str__( self ):
        return 'The tested polygons at least touch each other at (%f,%f)'\
               % ( self.x, self.y )
    def shift( self, dx, dy ):
        self.x += dx
        self.y += dy

def pair_overlapping( polygon1, polygon2, digits = None ):
    """ Find out if polygons are overlapping or touching.

    The function makes use of the quadrant method to find out if a point is
    inside a given polygon.

    polygon1, polygon2 -- Two arrays of [x,y] pairs where the last and the
        first pair is the same, because the polygon has to be closed.
    digits -- The number of digits relevant for the decision between
        separate and touching or touching and overlapping

    Returns 0 if the given polygons are neither overlapping nor touching,
    returns 1 if they are not overlapping, but touching and
    returns 2 if they are overlapping

    """

    def calc_walk_summand( r1, r2, digits = None ):
        """ Calculates the summand along one edge depending on axis crossings.

        Follows the edge between two points and checks if one or both axes are
        being crossed. If They are crossed in clockwise sense, it returns +1
        otherwise -1. Going through the origin raises the PolygonsTouching
        exception.

        Returns one of -2, -1, 0, +1, +2 or raises PolygonsTouching

        """
        x, y = 0, 1 # indices for better readability
        summand = 0 # the return value
        tx, ty = None, None # on division by zero, set parameters to None
        if r1[x] != r2[x]:
            ty = r1[x] / ( r1[x] - r2[x] ) # where it crosses the y axis
        if r1[y] != r2[y]:
            tx = r1[y] / ( r1[y] - r2[y] ) # where it crosses the x axis
        if tx == None: tx = ty
        if ty == None: ty = tx
        rsign = pylab.sign
        if digits != None:
            rsign = lambda x: pylab.sign( round( x, digits ) )
        sign_x = rsign( r1[x] + tx * ( r2[x] - r1[x] ) )
        sign_y = rsign( r1[y] + ty * ( r2[y] - r1[y] ) )
        if ( tx >= 0 ) and ( tx < 1 ):
            if ( sign_x == 0 ) and ( sign_y == 0 ):
                raise PolygonsTouching()
            summand += sign_x * pylab.sign( r2[y] - r1[y] )
        if ( ty >= 0 ) and ( ty < 1 ):
            if ( sign_x == 0 ) and ( sign_y == 0 ):
                raise PolygonsTouching()
            summand += sign_y * pylab.sign( r1[x] - r2[x] )
        return summand

    def current_and_next( iterable ):
        """ Returns an iterator for each element and its following element.

        """
        iterator = iter( iterable )
        item = iterator.next()
        for next in iterator:
            yield ( item, next )
            item = next

    def point_in_polygon( xy, xyarray, digits = None ):
        """ Checks if a point lies inside a polygon using the quadrant method.

        This moves the given point to the origin and shifts the polygon
        accordingly. Then for each edge of the polygon, calc_walk_summand is
        called. If the sum of all returned values from these calls is +4 or -4,
        the point lies indeed inside the polygon. Otherwise, if a
        PolygonsTouching exception has been caught, the point lies on ond of
        the edges of the polygon.

        Returns the number of nodes of the polygon, if the point lies inside,
        otherwise 1 if the point lies on the polygon and if not, 0.

        """
        moved = xyarray - xy # move currently checked point to the origin (0,0)
        touching = False # this is used only if no overlap is found
        walk_sum = 0
        for cnxy in current_and_next( moved ):
            try:
                walk_sum += calc_walk_summand( cnxy[0], cnxy[1], digits )
            except PolygonsTouching, (e):
                e.shift( *xy )
                touching = True
        if ( abs( walk_sum ) == 4 ):
            return len( xyarray )
        elif touching:
            return 1
        else:
            return 0

    def polygons_overlapping( p1, p2, digits = None ):
        """ Checks if one of the nodes of p1 lies inside p2.

        This repeatedly calls point_in_polygon for each point of polygon p1
        and immediately returns if it is the case, because then the polygons
        are obviously overlapping.

        Returns 2 for overlapping polygons, 1 for touching polygons and 0
        otherwise.

        """
        degree_of_contact = 0
        xyarrays = [ p1, p2 ]
        for xy in xyarrays[0]:
            degree_of_contact += point_in_polygon( xy, xyarrays[1], digits )
            if degree_of_contact >= len( xyarrays[1] ):
                return 2
        if degree_of_contact > 0:
            return 1
        else:
            return 0

    way1 = polygons_overlapping( polygon1, polygon2, digits )
    way2 = 0
    if way1 < 2: # Only if the polygons are not already found to be overlapping
        way2 = polygons_overlapping( polygon2, polygon1, digits )
    return max( way1, way2 )

def collection_overlapping_serial( polygons, digits = None ):
    """ Similar to the collection_overlapping function, but forces serial
    processing.

    """
    result = []
    pickle_polygons = [p.get_xy() for p in polygons]
    for i in xrange( len( polygons ) ):
        for j in xrange( i+1, len( polygons ) ):
            result.append( ( i, j, \
                pair_overlapping( pickle_polygons[i], pickle_polygons[j], \
                                  digits ) ) )
    return result

def __cop_bigger_job( polygons, index, digits = None ):
    """ This is a helper to efficiently distribute workload among processors.

    """
    result = []
    for j in xrange( index + 1, len( polygons ) ):
        result.append( ( index, j, \
            pair_overlapping( polygons[index], polygons[j], digits ) ) )
    return result

def collection_overlapping_parallel( polygons, digits = None, \
        ncpus = 'autodetect' ):
    """ Like collection_overlapping, but forces parallel processing.

    This function crashes if Parallel Python is not found on the system.

    """
    import pp
    ppservers = ()
    job_server = pp.Server( ncpus, ppservers=ppservers )
    pickle_polygons = [p.get_xy() for p in polygons]
    jobs = []
    for i in xrange( len( polygons ) ):
        job = job_server.submit( __cop_bigger_job, \
                                 ( pickle_polygons, i, digits, ), \
                                 ( pair_overlapping, PolygonsTouching, ), \
                                 ( "pylab", ) )
        jobs.append( job )
    result = []
    for job in jobs:
        result += job()
    #job_server.print_stats()
    return result

def collection_overlapping( polygons, digits = None ):
    """ Look for pair-wise overlaps in a given list of polygons.

    The function makes use of the quadrant method to find out if a point is
    inside a given polygon. It invokes the pair_overlapping function for each
    combination and produces and array of index pairs of these combinations
    together with the overlap number of that pair. The overlap number is 0 for
    no overlap, 1 for touching and 2 for overlapping polygons.

    This function automatically selects between a serial and a parallel
    implementation of the search depending on whether Parallel Python is
    installed and can be imported or not.

    polygons -- A list of arrays of [x,y] pairs where the last and the first
        pair of each array in the list is the same, because the polygons have
        to be closed.
    digits -- The number of digits relevant for the decision between
        separate and touching or touching and overlapping polygons.

    Returns a list of 3-tuples

    """
    try:
        import pp # try if parallel python is installed
    except ImportError:
        return collection_overlapping_serial( polygons, digits )
    else:
        return collection_overlapping_parallel( polygons, digits )