Augmented Reality (AR) hat sich in raschem Tempo zu einer transformative Technologie entwickelt, die die Grenzen zwischen der digitalen und physischen Welt verwischt. Egal, ob Sie sich immersive Spielerlebnisse, interaktive Bildungs-Apps oder praktische Lösungen für Branchen wie Architektur und Gesundheitswesen vorstellen – AR hat das Potenzial, sie alle zu revolutionieren. Ein entscheidendes Werkzeug, um Entwickler bei der Erstellung von AR-Anwendungen zu unterstützen, ist ARFoundation in Unity. In diesem Blogbeitrag werden wir uns mit der Welt von ARFoundation und Unity beschäftigen und deren Fähigkeiten, Vorteile und das unglaubliche Potenzial, das sie für die AR-Entwicklung bieten, erkunden.

Was ist ARFoundation?

ARFoundation ist ein leistungsstarkes Framework, das von Unity Technologies entwickelt wurde und Entwicklern ermöglicht, plattformübergreifende AR-Anwendungen sowohl für iOS- als auch für Android-Geräte zu erstellen. Es dient als Brücke zwischen der robusten Spieleentwicklungsumgebung von Unity und AR-Plattformen wie ARKit (iOS) und ARCore (Android). Durch die Nutzung von ARFoundation können Entwickler AR-Erlebnisse erstellen, die nahtlos auf verschiedenen Geräten funktionieren und die Fragmentierung, die oft mit der AR-App-Entwicklung verbunden ist, reduzieren.

Hauptmerkmale von ARFoundation

1. Plattformübergreifende Kompatibilität:
   ARFoundation abstrahiert die Unterschiede zwischen ARKit und ARCore und erleichtert so die Entwicklung von AR-Anwendungen, die auf beiden iOS- und Android-Geräten konsistent funktionieren. Diese plattformübergreifende Kompatibilität reduziert die Entwicklungszeit und ermöglicht es Entwicklern, ein breiteres Publikum zu erreichen.
2. Tracking der realen Welt:
   ARFoundation bietet Zugriff auf Funktionen wie Bewegungsverfolgung, Umgebungserkennung und Ebenenerkennung. Dadurch können AR-Anwendungen virtuelle Objekte an die reale Welt anheften, sodass Benutzer mit ihnen interagieren können, als wären sie physisch vorhanden.
3. Geräteunterstützung:
   ARFoundation unterstützt eine breite Palette von Geräten, von den neuesten Flaggschiff-Smartphones bis hin zu älteren Modellen. Dadurch wird sichergestellt, dass Ihre AR-App eine breite Benutzerbasis erreichen kann, was ihr Marktpotenzial erhöht.
4. Erweiterbarkeit:
   Unity’s ARFoundation ist sehr erweiterbar und ermöglicht es Entwicklern, benutzerdefinierte AR-Lösungen zu erstellen, die ihren spezifischen Projektanforderungen entsprechen. Diese Flexibilität fördert Innovation und Kreativität in der AR-App-Entwicklung.

Vorteile der Verwendung von ARFoundation mit Unity

1. Bekannte Entwicklungsumgebung:
   Unity ist eine beliebte Spieleentwicklungsumgebung, und viele Entwickler sind bereits mit ihrer Benutzeroberfläche und ihren Werkzeugen vertraut. Durch die Verwendung von ARFoundation innerhalb von Unity können Entwickler ihre vorhandenen Fähigkeiten nutzen, um AR-Erlebnisse zu erstellen, was die Einarbeitungszeit reduziert.
2. Reiche Ökosystem:
   Unity verfügt über ein umfangreiches Ökosystem von Assets, Plugins und Ressourcen, die nahtlos in AR-Projekte integriert werden können. Dies erleichtert den Entwicklungsprozess und verbessert die Qualität von AR-Anwendungen.
3. Schnelle Prototypenerstellung:
   Die Echtzeit-Rendering-Fähigkeiten von Unity ermöglichen es Entwicklern, AR-Konzepte schnell zu erstellen und zu überarbeiten, was den Entwicklungszyklus verkürzt und die Time-to-Market reduziert.
4. Gemeinschaftsunterstützung:
   Unity verfügt über eine blühende Entwicklergemeinschaft, die ihr Wissen, Tutorials und Lösungen teilt. Dieses Unterstützungsnetzwerk kann unschätzbar sein, wenn Herausforderungen bei der AR-Entwicklung auftreten.

Beispiele für ARFoundation-Anwendungen

1. Spiele: Erstellen Sie immersive, standortbasierte AR-Spiele, die digitale Inhalte in die reale Welt einblenden.
2. Bildung: Entwickeln Sie interaktive Bildungs-Apps, die Geschichte, Wissenschaft und Kunst durch erweiterte Erlebnisse zum Leben erwecken.
3. Einzelhandel: Ermöglichen Sie es Kunden, Produkte in ihrer realen Umgebung zu visualisieren, bevor sie einen Kauf tätigen.
4. Gesundheitswesen: Bauen Sie AR-Anwendungen für medizinische Schulungen, Operationssimulationen und Patientenaufklärung.

Verständnis der AR Foundation in Unity

Das Diagramm zeigt die Architektur der Entwicklung von Augmented und Virtual Reality (AR/VR) innerhalb des Unity-Frameworks und konzentriert sich dabei auf die AR Foundation.

• Mixed and Augmented Reality Studio (MARS):

Ein fortschrittlicher Werkzeugkasten, der die Erstellung von AR-Erfahrungen erleichtert, die intelligent mit der realen Welt interagieren. MARS vereinfacht die Entwicklung von AR-Apps und stellt sicher, dass sie in einer Vielzahl von realen Szenarien funktionieren.

• AR Foundation:

Dient als Grundlage für die AR-Entwicklung in Unity. Sie bietet eine gemeinsame API, die auf mehreren AR-Geräten funktioniert, sodass Entwickler ihre AR-Apps einmal schreiben und auf verschiedenen Plattformen bereitstellen können.

• XR Interaction Toolkit:

Hierbei handelt es sich um einen Satz von Werkzeugen und Funktionalitäten, die es Entwicklern erleichtern, Interaktivität in AR/VR-Erlebnisse zu implementieren.

• Developer Tools (Entwicklungswerkzeuge):

Dies sind zusätzliche Dienstprogramme und Tools, die Entwicklern helfen, ihre AR/VR-Anwendungen zu erstellen, zu testen und zu debuggen.

• XR Subsystems:

Dies sind die Kernfunktionen, die für AR/VR-Erlebnisse erforderlich sind:

• Display & Input: Die Grundlagen von visueller Ausgabe und Benutzereingabe.
• Environment (Umgebung): Erkennt und interagiert mit der realen Umgebung.
• Faces (Gesichter): Erkennt und verfolgt menschliche Gesichter.
• Raycast: Sendet Strahlen aus, um Schnittpunkte mit realen Objekten zu erkennen.
• Kamera, Ebenen, Bildverfolgung, Objektverfolgung und Netzwerk: Wesentliche Funktionen, damit AR mit der realen Welt und virtuellen Objekten interagieren kann.

• Unity XR SDK:

• Die Softwareentwicklungs-Kits speziell für verschiedene AR-Plattformen. Sie ermöglichen es, AR Foundation Apps auf verschiedenen Geräten bereitzustellen.
  • ARCore XR und ARKit XR: SDKs für Android- bzw. iOS-Plattformen.
  • Oculus XR: Für Oculus-Geräte.
  • Windows XR: Für Windows Mixed Reality-Geräte.
  • Magic Leap: SDK für die Magic Leap-Plattform.
  • VSP/3rd: Stellt Drittanbieter- oder andere benutzerdefinierte SDKs dar.

1. XR Plugin Framework und Anbieter (Provider):

• Dies ermöglicht Erweiterbarkeit und stellt sicher, dass Unity neue Funktionen oder Plattformen unterstützen kann, sobald sie auftauchen.

Kurz gesagt, die AR Foundation fungiert als Brücke und ermöglicht es Entwicklern, AR-Erfahrungen zu schaffen, die auf verschiedenen Geräten und Plattformen bereitgestellt werden können, ohne ihre Anwendungen für jede einzelne Plattform neu schreiben zu müssen. Sie rationalisiert die AR-Entwicklung in Unity und gewährleistet einen effizienteren und einheitlichen Arbeitsablauf.

Fazit

ARFoundation in Unity ist ein Game-Changer für Entwickler, die die aufregende Welt der Augmented Reality erkunden möchten. Mit seiner plattformübergreifenden Kompatibilität, seinen Fähigkeiten zur Verfolgung der realen Welt und der Integration in das umfangreiche Ökosystem von Unity ermöglicht ARFoundation Entwicklern die Schaffung innovativer und fesselnder AR-Anwendungen, die Benutzer auf verschiedenen Geräten und Plattformen begeistern können. Da die AR-Technologie weiterhin fortschreitet, bieten ARFoundation und Unity die Werkzeuge, um die Zukunft der AR-Erlebnisse zu gestalten, was diesen Bereich für Entwickler zu einem spannenden Raum macht, den sie erkunden und gestalten können.

The post ARFoundation mit Unity appeared first on Mobile USTP MKL.

1. Einführung in WebSockets:

Was sind WebSockets?

WebSockets repräsentieren eine fortschrittliche Technologie, die es ermöglicht, eine interaktive Kommunikation zwischen dem Client und einem Server zu erstellen. Im Gegensatz zu herkömmlichen HTTP-Verbindungen, bei denen der Client (z. B. ein Webbrowser) eine Anfrage an den Server sendet und auf eine Antwort wartet, ermöglichen WebSockets eine bidirektionale Kommunikation. Das bedeutet, dass sowohl der Server als auch der Client Daten initiieren und senden können, ohne auf eine Anfrage zu warten.

Warum sind sie nützlich?

Traditionelle HTTP-Anfragen sind zustandslos und nicht dauerhaft. Jede Anfrage öffnet eine neue Verbindung, und nachdem die Daten übertragen wurden, wird diese Verbindung geschlossen. Dieser Prozess kann ineffizient sein, insbesondere wenn Echtzeitdaten oder häufige Updates erforderlich sind.

WebSockets hingegen bieten eine dauerhafte Verbindung, die nach dem initialen Handshake offen bleibt. Dies ermöglicht eine schnellere Datenübertragung, da der Overhead des ständigen Verbindungsaufbaus und -abbaus entfällt. Dies ist besonders nützlich für Anwendungen wie Online-Spiele, Chat-Anwendungen, Finanz-Dashboards und andere Echtzeitanwendungen.

Anwendungsfälle für WebSockets:

Einige gängige Anwendungsfälle für WebSockets sind:

• Chat-Anwendungen
• Online-Multiplayer-Spiele
• Live-Sportergebnisse oder Börsenticker
• Kollaborative Tools wie gemeinsame Dokumentenbearbeitung
• Benachrichtigungen in Echtzeit

2. Einführung in socket.io:

Was ist socket.io?

socket.io ist eine JavaScript-Bibliothek, die es Entwicklern erleichtert, Echtzeit-Webanwendungen zu erstellen. Sie bietet Abstraktionen für WebSockets und viele Fallbacks für ältere Technologien, falls WebSockets nicht verfügbar sind. Dies macht sie zu einer robusten Lösung für unterschiedliche Umgebungen und Browser-Kompatibilitäten.

Vorteile von socket.io gegenüber reinen WebSockets:

• Kompatibilität: socket.io funktioniert nicht nur mit WebSockets, sondern bietet auch Fallbacks für ältere Technologien, was die Kompatibilität mit älteren Browsern sicherstellt.
• Einfachheit: Die API von socket.io ist einfach und intuitiv, was den Einstieg erleichtert.
• Erweiterte Funktionen: socket.io bietet zusätzliche Funktionen, die über reine WebSockets hinausgehen, wie z. B. Räume, Namensräume und Broadcasting.
• Wiederverbindung: socket.io versucht automatisch, die Verbindung wiederherzustellen, wenn sie unterbrochen wird.

Hauptkomponenten: Client- und Serverbibliothek:

socket.io besteht aus zwei Hauptkomponenten:

1. Serverbibliothek: Typischerweise in einer Node.js-Anwendung verwendet. Sie ermöglicht es dem Server, Verbindungen von Clients zu akzeptieren und mit ihnen zu kommunizieren.
2. Clientbibliothek: Diese wird in der Webanwendung des Benutzers ausgeführt und ermöglicht es dem Client, sich mit dem Server zu verbinden und Nachrichten auszutauschen.

3. Frontend-Implementierung mit Angular und socket.io:

In modernen Webanwendungen wie Pingo ist es üblich, Frameworks wie Angular zu verwenden, um die Entwicklung zu erleichtern und den Code zu strukturieren. In diesem Kapitel werden wir uns ansehen, wie socket.io in eine Angular-Anwendung integriert werden kann.

Einrichtung und Abhängigkeiten:

Zunächst müssen Sie die socket.io-client-Bibliothek zu Ihrem Angular-Projekt hinzufügen. Dies kann mit npm oder einem anderen Paketmanager erfolgen:

npm install socket.io-client

WebsocketService:

Der WebsocketService ist ein zentraler Dienst, der die gesamte Logik für die Kommunikation mit dem socket.io-Server kapselt. Hier ist eine kurze Übersicht über den bereitgestellten Code:

• Initialisierung: Beim Erstellen des Dienstes wird eine Verbindung zum socket.io-Server hergestellt, welcher in diesem Fall das Pingo-Backend darstellt.
• Räume betreten und verlassen: Die Methoden joinRoom und leaveRoom ermöglichen es dem Client, einem bestimmten Raum beizutreten oder ihn zu verlassen. Dies ist nützlich, wenn Sie Chaträume oder andere segmentierte Kommunikationskanäle haben.
• Nachrichten senden: Die Methode sendMessage ermöglicht es dem Client, eine Nachricht (in diesem Fall ein Chat-Objekt) an den Server zu senden.
• Nachrichten empfangen: Die Methode onMessageReceived gibt ein Observable zurück, das jedes Mal einen Wert ausgibt, wenn eine Nachricht vom Server empfangen wird. Dies ermöglicht es anderen Teilen Ihrer Angular-Anwendung, auf eingehende Nachrichten zu reagieren.

Integration in Komponenten:

Mit dem WebsocketService können Sie nun in Ihren Angular-Komponenten auf socket.io-Funktionen zugreifen. Zum Beispiel könnten Sie eine Chat-Komponente haben, die den WebsocketService verwendet, um Nachrichten zu senden und zu empfangen.

@Component({
  selector: 'app-chat',
  templateUrl: './chat.component.html',
  styleUrls: ['./chat.component.css']
})
export class ChatComponent implements OnInit {
  public messages: Chat[] = [];

  constructor(private websocketService: WebsocketService) {}

  ngOnInit(): void {
    this.websocketService.onMessageReceived().subscribe((chat: Chat) => {
      this.messages.push(chat);
    });
  }

  send(message: string): void {
    const chatMessage: Chat = {
    };
    this.websocketService.sendMessage(chatMessage);
  }
}

4. Backend-Implementierung mit NestJS und socket.io:

NestJS ist ein progressives Node.js-Framework zum Erstellen effizienter, zuverlässiger und skalierbarer Serverseitenanwendungen. Es verwendet moderne JavaScript, ist auf TypeScript aufgebaut und kombiniert Elemente von OOP (Objektorientierte Programmierung), FP (Funktionale Programmierung) und FRP (Funktionale Reaktive Programmierung).

ChatGateway:

Der ChatGateway ist ein zentrales Element, das die WebSocket-Kommunikation mit dem Frontend steuert. Hier sind einige der Hauptfunktionen und -methoden:

• WebSocketServer: Dieser Dekorator wird verwendet, um eine Instanz des socket.io-Servers zu erstellen.
• handleConnection: Diese Methode wird aufgerufen, wenn ein neuer Client eine Verbindung herstellt. Hier werden auch verschiedene Ereignishandler für den Client definiert, wie z.B. das Senden von Nachrichten und das Betreten oder Verlassen von Räumen.
• handleDisconnect: Diese Methode wird aufgerufen, wenn ein Client die Verbindung trennt. Hier können Sie jegliche Aufräumarbeiten oder Benachrichtigungen durchführen.
• afterInit: Diese Methode wird aufgerufen, nachdem der WebSocket-Server initialisiert wurde. Sie können hier jegliche Initialisierungslogik hinzufügen.

ChatService:

Der ChatService ist verantwortlich für die Logik rund um den Chat. Er interagiert mit dem Datenbank-Repository, um Chats zu speichern und abzurufen, und verwendet den Mapper, um zwischen DTOs (Data Transfer Objects) und Entitäten zu konvertieren.

• newChat: Diese Methode erstellt einen neuen Chat-Eintrag in der Datenbank. Sie nimmt ein ChatDto entgegen, konvertiert es in eine Chat-Entität und speichert es dann über das Repository.
• getChatByRoom: Diese Methode ruft alle Chats für einen bestimmten Raum ab. Wenn keine Chats gefunden werden, wird eine NotFoundException ausgelöst.

Zusätzliche Komponenten:

Sie haben auch erwähnt, dass es zusätzliche Komponenten wie eine Entity, ein Repository, ein DTO und einen Mapper gibt. Auch wenn sie hier nicht im Detail beschrieben sind, spielen sie eine entscheidende Rolle:

• Entity: Definiert die Struktur und Beziehungen der Chat-Daten in der Datenbank.
• Repository: Bietet Methoden zum Abrufen und Speichern von Daten in der Datenbank.
• DTO: Ein Objekt, das Daten zwischen Client und Server überträgt, oft mit einer etwas anderen Struktur als die Datenbank-Entity.
• Mapper: Ein Tool, das die Konvertierung zwischen DTOs und Entitäten erleichtert.

Mit dieser Backend-Implementierung habe ich die Chat-Funktion in Pingo implementiert. Die Kombination von NestJS und socket.io bietet eine leistungsstarke und flexible Lösung für moderne Webanwendungen.

The post Pingo-Websockets Implementierung mit socket.io appeared first on Mobile USTP MKL.

Mit den jüngsten Fortschritten im auf Deep Learning basierenden NLP ist es einfacher denn je geworden, modernste Modelle auf Ihre eigenen Texte anzuwenden. In diesem Artikel stelle Ich euch die Methode des Transfer Learning vor.

Mit der fortschreitenden Digitalisierung von Unternehmen wächst die Datenmenge rasant. Während einige Daten in sorgfältig ausgewählten Formaten in hervorragend konstruierten relationalen Datenbanken gespeichert werden, handelt es sich bei den meisten tatsächlich um unstrukturierte Daten wie Text, Video und Bild. Das Sammeln von Informationen aus dieser Art von Dateien wurde erst in den letzten Jahren dank großer Fortschritte im Deep Learning möglich. Natural Language Processing (NLP) ist eine Disziplin im Bereich des maschinellen Lernens, die sich auf alle Arten von Textdaten konzentriert. Es ist heutzutage ein besonders spannendes Feld, weil wir wöchentlich neue Veröffentlichungen sehen, eine sehr aktive Open-Source-Community und gleichzeitig unzählige Möglichkeiten, NLP-Modelle in der realen Welt zu platzieren.

Transfer Learning: Den Weg vom Gewächshaus aufs Feld vereinfachen

Transfer Learning ist die Idee, an einer Art von Problem zu lernen (Pre-Training) und das erworbene Wissen auf ein neues Problem zu übertragen, wo es als Grundlage für weiteres verfeinertes Lernen verwendet werden kann (Fine-Tuning). Die Modelle können mit weniger Trainingsdaten an spezifische Geschäftsprobleme angepasst werden und erzielen sogar eine bessere Leistung. Diese Idee ist nicht neu und wurde erfolgreich auf viele Computer-Vision-Probleme angewendet.

Das Transfer-Learning für NLP ist jedoch sehr herausfordernd, da das Modell das Erlernen eines grundlegenden, aber allgemeinen Sprachverständnisses erfordern würde. Aber wie können wir einem Computer beibringen, was ein Wort bedeutet? Diese Aufgabe ist zentral für das Gebiet des NLP, und seit ihrer Veröffentlichung waren word2vec und GloVe die Algorithmen der Wahl zur Generierung von Wortvektoren .In den letzten Jahren gab es eine ganze Reihe neuer Sprachmodelle, die genau dieses Problem angegangen sind und deren erlerntes Wissen auf nachgelagerte Aufgaben übertragen hat, was zu erheblichen Leistungsverbesserungen geführt hat. 

Zum Glück gibt es ein paar Open-Source-Pakete, die Sie bei diesem Prozess unterstützen. Das ursprüngliche Tensorflow-Repository verfügt über verschiedene BERT-Modelle für verschiedene Sprachen und bietet grundlegende Skripte, um die Ergebnisse in der Arbeit zu replizieren. Der pytorch-pretrained-bert von Huggingface hat einige nette Ergänzungen, darunter mehr Modellarchitekturen, erweiterte Multi-GPU-Unterstützung und zusätzliche Skripte für die Feinabstimmung von Sprachmodellen. Sein Zweck ist jedoch immer noch eher die Replikation von Forschungsergebnissen und ein Ausgangspunkt für eigene Modelle. In dem Framework für Adapting Representation Models ( FARM ) soll das verwändert werden durch:

• einfache & schnelle Anpassung vortrainierter Modelle an Ihr Zielproblem
• leistungsstarke Protokollierung und Verfolgung von Modellen
• Persistierende Modellparameter und -konfigurationen für Reproduzierbarkeit
• einfache Visualisierung und Bereitstellung zur Präsentation Ihres Prototyps

Nachdem ich es für meine Bachelor-Arbeit sehr nützlich fand, entschied ich mich, es mit der euch zu teilen. Der Bau eucres eigenen hochmodernen Modells mit FARM erfordert nur wenige Schritte:

• 1) Wählt ein vortrainiertes Modell aus

• 2) Fügt einen Prediction-Head hinzu, der zu Ihrem Zielproblem passt

• 3) Erstellt einen Datenprocessor, der Ihre Dateien einliest und die Daten in das geeignete Format für das Modell konvertiert

• 4) Trainiert das Modell

In diesem Jupyter-Notebook gibt es von den Entwicklern ein eigenes Tutorial in einem Jupyter Notebook. Achtung, bei den Package-Dependencies wird es wahrscheinlich zu Problemen kommen…

The post <strong>Transfer Learning</strong> appeared first on Mobile USTP MKL.

Im 1. Semester haben wir uns auf die Entwicklung der Android-App konzentriert.

Team | Rollen

• Manuel Hecht
  • Mediathek API (Backend)
  • Home Screen mit Sendungsübersicht
  • Sendungssuche
  • Testen
• Mohamed Abd-El-Rehim
  • Userverwaltung | Login & Registrierung
  • Firebase Verwaltung
  • Testen

• Florian Bauer
  • UI-Design der App
  • Videoplayer-Integration
  • Testen

Projektorganisation

Wir verwenden für unsere Projekt GitLab auf dem FH-internen Server.

GitLab | Flimmerkiste (Link)

Entwicklung

Für die Umsetzung von unserem Semesterprojekt haben wir uns für Flutter, das Entwicklungs-Kit von Google entschieden.

Flutter

Flutter ist ein Open-Source-Framework für die Entwicklung mobiler Anwendungen, mit dem Entwickler hochwertige, plattformübergreifende mobile Anwendungen mit einer einzigen Codebasis erstellen können. Das Hauptmerkmal von Flutter ist die Fähigkeit, schöne, reaktionsfähige und schnelle Anwendungen zu erstellen, die einfach zu warten sind.

Wir wollen unsere Anwendung für möglichst viele Plattformen in Zukunft anbieten, diese sollen von Semester zu Semester ergänzt werden.

Das Erlernen einer Cross-Platform-Entwicklungsumgebung war ein wichtiger Entscheidungsgrund für alle Projektmitglieder. Bis vor Projektbeginn hatte kein Mitglied Berührungspunkte mit so einer All-in-One Umgebung.

Der klare Nachteil war die längere Einschulungsphase bei allen Teammitglieder, ein Flutter-Workshop wäre hier hilfreich gewesen. Zum Beispiel konnten gewisse Verhaltensweisen von Flutter nicht nachvollzogen (z.B. States) werden.

Design

Fokussierung des Designs erfolgte fürs 1. Semester auf die Android Variante.

Figma-Designentwurf V1

Backend

Datenbank | Google Firebase

Für unsere Benutzerverwaltung verwenden wir Google Firebase als Datenbank. Derzeit werden folgende Tabelle/Daten gespeichert:

• Benutzer:innen
  • Mail, Name

• Favoriten = Sendungen
  • Kanal, Sendungstitel

MediathekView API

Als Datenquelle verwenden wir die API von MediathekView. Diese darf aus rechtlichen Gründen leider nicht auf unserer Seite in einem eigenen Backend abgespeichert werden Aus diesem Grund holen wir uns nur temporär per API-Abfage die jeweiligen benötigten Daten.

MediathekView durchsucht die Online-Mediatheken verschiedener öffentlich-rechtlicher Sender und listet diese gefundenen Sendungen auf. Es werden die Videobeiträge aus den Mediatheken direkt verwendet, das heißt das Hosting findet bei den jeweiligen Sendern statt.

MediathekView kann aus diesem Grund nur Sendungen anzeigen, die in den Mediatheken der Sender selbst noch als Videos angeboten werden.

Die Sendungen vom ORF sind aus rechtlichen Gründen nur aus den letzten sieben Tagen verwendbar.

Mediathek View Web (Link)

Derzeit werden die Mediatheken der folgenden Sender unterstützt:

• ARD (Das Erste)
• Arte (deutsch, englisch, französisch, spanisch, italienisch und polnisch)
• alpha
• BR (Bayerischer Rundfunk)
• HR (Hessischer Rundfunk)
• MDR (Mitteldeutscher Rundfunk)
• NDR (Norddeutscher Rundfunk)
• RBB (Rundfunk Berlin-Brandenburg)
• rbtv (radiobremen)
• SR (Saarländischer Rundfunk)
• SWR (Südwestrundfunk)
• WDR (Westdeutscher Rundfunk)
• ZDF (Zweites Deutsches Fernsehen)
• ZDFinfo
• ZDFneo
• zdf-tivi
• Gemeinschaftsprogramme von ARD und ZDF
• 3Sat
• Funk
• Kika (Kinderkanal von ARD und ZDF)
• Phoenix
• DW TV (Deutsche Welle)
• ORF (Österreichischer Rundfunk)
• SRF (Schweizer Rundfunk) inkl. Podcasts

Eine Abfrage an die MediathekViewWeb API liefert folgende Infos:

• Kanalname (channel)
• Sendungsname (topic)
• Sendungstitle (title)
• Sendungsbeschreibung (description)
• Zeitstempel (timestamp,filmlisteTimestamp)
• Sendungsdauer (duration)
• Dateigröße (size)
• Sendungslink auf die Website des jeweiligen Senders (url_website)
• Untertitel zur Sendung (url_subtitle)
• Videolink in mittlerer Qualität (url_video)
• Videolink in niedrigster Qualität (url_video_low)
• Videolink in hoher Qualität (url_video_high)
• MediathekView-ID (id)

Ein Beispiel aus der ARD-Mediathek:

MediathekViewWeb API Samplecode (Link)

Für unsere jetzige Implementierung verwenden wir zwei verschiedene Queries:

• Query für den Home Screen
  • Abfrage nach allen Videos eines Senders (channel).
  • Es werden die aktuellsten 10 Sendungen (DESC) des Kanals als Ergebnis geliefert.

• Query für die Suche nach einer Sendung
  • Abfrage erfolgt nach dem Sendungstitle (title).
  • Es werden die aktuellsten 10 Sendungen (DESC) mit einer Übereinstimmung des Suchwortes als Ergebnis geliefert.

Folgende Felder erhalten wir als Antwort (JSON), die wir für das Frontend weiterverarbeiten.

• Feld “topic”:
• Feld “title”:
• Feld “channel”:
• Feld “url_video”:
• feld “filmlisteTimestamp”:
• feld “duration”
• feld “description”

Funktionen

Home Screen

Die aktuellsten zehn Sendungen ausgewählter Kanäle werden als scrollbare Listenzeile angezeigt.

Suche nach Sendungstitel

Es werden die zehn neuesten Ergebnisse gezeigt.

Bei einem Ergebnisumfang größer zehn, können die Ergebnisse erweitert werden.

Benutzerprofil

Die Flimmerkiste enthält eine Benutzerprofil-Funktion. Mit dieser Funktion kann man sein persönliches Konto in der App erstellen und verwalten. Mit einem Benutzerprofil kann man Lieblingssendungen speichern. Das Profil kann folgende Daten anpassen:

• Profilfoto
• Mailadresse
• Name
• Passwort

Und es können Sendungen favorisiert werden.

Video-Player

Der Hauptbestandteil von Flimmerkiste ist das Video-Player, welcher die jeweiligen Sendungsvideos des Kanals abspielt. Um auf die Anforderungen des Players einzugehen, wird zuerst eine Übersicht der Spezifikationen der abzuspielenden Videos aufgelistet.

Alle Videos aus den Mediatheken werden in zwei Varianten (MP4 & HLS-Stream) angeboten.

Encodierung der Videos:

• Container: MPEG-4
• Video: AVC (H264)
• Audio: AAC LC (Stereo)

MP4

Niedrige Qualität

Mittlere Qualität

Höchste Qualität

HLS-Stream

Videos von ORF und SRF werden nicht als *.mp4 angeboten, sondern nur als HLS-Stream zur Verfügung gestellt. Eine Manifest-Datei (*.m3u8) definiert in welcher Qualität das Video abgespielt wird.

ORF:

Niedrige Qualität

#EXT-X-STREAM-INF:BANDWIDTH=1089858,CODECS="avc1.100.30,mp4a.40.2",RESOLUTION=640x360

Mittlere Qualität

#EXT-X-STREAM-INF:BANDWIDTH=2123246,CODECS="avc1.100.31,mp4a.40.2",RESOLUTION=960x540

Höchste Qualität

#EXT-X-STREAM-INF:BANDWIDTH=3417151,CODECS="avc1.100.31,mp4a.40.2",RESOLUTION=1280x720

SRF:

Die Manifest-Datei (*.m3u8) verweist auf die einzelnen Videosegmente (.ts) in der jeweiligen Qualitätsstufe (Low, Mid, High).

#EXTINF:4.840,

segment-1-f4-v1-a1.ts

#EXTINF:6.000,

segment-2-f4-v1-a1.ts

Der Player muss folgenden Anforderungen in erster Phase erfüllen:

• Abspielen von Videos, die als *.mp4 und *.m3u8 gehostet sind.
• Besitzt Basis-Steuerungselemente: Zeitleiste, Lautstärkeregelung, Play-/Pausefunktion und Vollbildmodus
• Unterstützung für Android & iOS, idealerweise auch Web
• Anpassbare Playerelemente für zukünftige Features wie z.B. die Einstellung der Videoqualität per Steuerungselement, Untertiteleinblendung

Die Flutter-Community hat bereits einige nützliche Player-Plugins für Flutter entwickelt. Diese wären:

video_player

• https://pub.dev/packages/video_player
• Dieser Player ist der stabilste (Version 2.5.2) von allen getesteten Plugins.
• Alle notwendigen Plattformen werden unterstützt.
• Nur Basisfunktionen verfügbar, kaum angepasste Funktionen verfügbar.
• Nur *.mp4 gehostete Videos abspielbar.

chewie

• https://pub.dev/packages/video_player
• Ein Video-Player mit erweiterten Steuerungselementen.
• Alle notwendigen Plattformen werden unterstützt.
• Erweiterbare Steuerungselemente verfügbar.
• HLS-Videostream und MP4-Videos abspielbar.
• Das Plugin basiert auf video_player.
  

better_player

• https://pub.dev/packages/better_player
• Instabiler Player-Plugin mit den umfangreichsten Funktionen.
• Unterstützung von Android & iOS
• Alle Videoformate abspielbar.
• Umfangreiches Set an Steuerungselementen.
• Das Plugin basiert auf chewie.

chewie wurde als Video-Player für die erste Phase gewählt. Es konnten alle Use-Cases an Mediatheken-Videos damit problemlos abgespielt werden.

Plattform-Verhalten:

• Android: Reibungslose Verwendung
• iOS: Konnte derzeit nicht getestet werden
• Web: Problem mit Vollbildmodus, beim Verlassen wird Video wieder von Beginn abgespielt

Learnings

• Sammlung erster Erfahrungen mit Cross-Plattform-Entwicklung (Flutter)
• Allgemeiner Einstieg in Programmiersprache Dart 
• State-Management in Flutter, zu Beginn einige Schwierigkeiten mit Verständnis
• Vertiefung des Google Firebase Wissen (Auth & Storage)
• Videoplayer-Handling auf den verschiedenen Plattformen

Roadmap

• Stabile Web-Version
• iOS-Version
• Videoqualität per Player einstellbar
• Einbindungsmöglichkeiten von Untertiteln
• Navigation Bar zu einer verbesserten Navigation
• Code Abstraktionen
• Angepasste Bilder für Sendungen
• Auswahl der Sender für Home-Screen
• Empfehlungen für Sendungen aufgrund von Favoriten
• Erstellen von Playlisten (Watch-Listen)
• Verbesserte Suche mit Filtermöglichkeiten

Fazit

Die Flimmerkiste ist eine hervorragende Lösung für alle, die in einer App das Videoangebot aller deutschsprachigen öffentlich-rechtlichen TV-Sender sehen wollen. Die Funktionen der App, einschließlich der Wiedergabe eines Videos, eines Benutzerprofils und einer Liste von Kanälen in Kategorien, bietet ein umfassendes und personalisiertes Medienerlebnis. Mit der weiteren Entwicklung der App wird sie zu einem noch wertvolleren Werkzeug für Medienkonsumenten werden.

The post Flimmerkiste | Semesterprojekt appeared first on Mobile USTP MKL.

Background

Deforestation

Deforestation claims to be the major source of greenhouse gas emissions in the world. Even outranking the burning of fossil fuels, deforestation is one of the primary sources of concern regarding climate change. Studies have shown that in connection with forest fires, deforestation within the region of the Brazilian Amazon makes up 48% of the total emissions. It impacts the conservation of biodiversity and the associated ecosystem within that region directly. Further implications of deforestation are the loss of species, the reductions in seasonal rainfall, and the organization of the environment. (Ortega et al. 2019).

Remote Sensing

The usage of remote sensing imagery has been essential to keep track of deforestation.
NASA defines remote sensing as “the acquiring of information from a distance via remote sensors on satellites and aircraft that detect, and record reflected or emitted energy” which further “enables data-informed decision making based on the current state of our planet” (NASA 2019) It covers a cost-reductive method in order to gain a broader spectrum of data, especially within hardly accessible areas. Additionally, remote sensing has proven to be well suited to represent the condition of the forests by generating spatial maps that serve as visualizations, helping outline the severity of damage (Xulu et al. 2019).

Change Detection

Change detection is a common task within the usage of remote sensing. It defines the process of analyzing the state of an object at different times. Therefore, it can be used for understanding and tackling deforestation. A major task of change detection is to minimize noise (variations in shadows or lighting) in order to get a clear map of unchanged and changed areas. Many different change detection methods based on Machine Learning have been proposed so far. Those experiments usually use classification, that have a set of stacked temporal images as input, and use complex algorithms to determine changes. Deep Learning has become more attention regarding the use within remote sensing data due to the fact that it can automatically extract features from the image dataset, high-level semantic segmentation, nonlinear problem modeling, and mapping in complex environments. Deep Learning methods have shown better results in comparison to classic machine learning methods regarding change detection techniques. The complexity of all three dimensions of the image (temporal, spectral and spatial) and the power of pattern recognition linked to deep learning has proven to be especially effective (de Bem et al. 2020).

Deep learning algorithms that use image-based change detection learn segmentation directly from bi-temporal image pairs, thus avoiding the negative effects associated with pixel patches. The convolutional neural network (CNN) is a leading architecture among DL algorithms. Through convolutional filters, CNNs can identify patterns within an n-dimensional context with multiple abstraction levels and use them for inference instead of traditional ML algorithms (de Bem et al. 2020).

Change Detection with Deep Learning

In this section, several deep learning methods for change detection will be presented. Those algorithms are being used in several remote sensing and spatial information studies lately.

Convolutional Neural Network (CNN)

The Convolutional Neural Network (CNN) is the most commonly used deep learning method in regard to computer vision. The CNN channels the pixel characteristics in a convolutional process and creates a feature map with characteristics by resizing and pooling of the input image. At the end of this process, a fully-connected layer is attached, that could be applied to a classifier (Lee et al. 2020).

Early Fusion (EF)

The Early Fusion approach is inspired by the CNN model created by Daudt et al. (2018), which demonstrated good results in the task of change detection within urban areas. The EF represents the concatenation of two image pairs from two different dates as the first step of the network. Subsequently, the input image will be processed by a series of seven convolutional layers and two fully connected layers. The softmax layer with two outputs carries out the final classification as shown in Figure 1. The dataset includes pairs of Landsat 8-OLI images from 2016 and 2017, by PRODES (Shimabukuro et al. 2006), that compares areas in the Brazilian Amazon where a significant deforestation process has been tracked. With the EF method an overall accuracy of 97% has been achieved Ortega et al. (2019).

Siamese Network (S-CNN)

The Siamese Convolutional Neural Network is an adaptation of a traditional CNN, that includes two identical branches that share the same hyperparameters and weights values (Zhang et al. 2018) as shown in Figure 2. Daudt et al. (2018) started to implement an S-CNN for change detection in urban areas. The idea is to process the input patches through four convolutional layers with shared weights in both branches and concatenating the outputs using fully connected layers. This leads to a final feature vector that is the input for a classifier that tells if there was deforestation or no deforestation in that time span. Ortega et al. (2019) used the same dataset for the S-CNN, as they did for the EF approach, in order to compare both methods. Overall, the S-CNN was consistently better in terms of F1-Score and accuracy than the Early Fusion method.

Fully Convolutional Network (FCN)

The Fully Convolutional Network (FCN) overcomes the limitation of the CNN, for example the missing image location information by replacing the dense layers with fully connected layers (Shelhamer et al. 2016). In this section, SegNet (Badrinarayanan et al. 2016) and U-Net (Ronneberger et al. 2015), both FCN-based, are compared in a study for classifying deforestation in Korean forests (Lee et al. 2020).

U-Net

U-Net is applied mainly for the segmentation of small numbers of medical related images and was developed based on the FCN architecture. It includes an encoder and a decoder path on the. The encoder path takes an image patch with multiple channels as input and performs sub-sampling by deploying convolutional layers, ReLU activation functions and max pooling. On the other side, U-Net has two distinctive characteristics in its expansive path: the copy-and-crop step, which converts source information into contracting information using a skip connection, and convolution layers without fully connected layers in the image restoration stage. The network predicts the boundary value of the patch by mirroring the input images. By using patch units instead of sliding windows, U-Net improves its speed over previous networks. It solves the FCN problem of localization by concatenating the image using the copy-and-crop function. U-Net classified forests and non-forests, with 98.4% and 88.5% accuracy, respectively.
The overall accuracy of the U-Net model was 74.8%, which was 11.5% higher than that of SegNet (63.3%) (Lee et al. 2020).

SegNet

Compared to other methods of learning, SegNet is effective both in terms of learning speed and accuracy. Both an encoder and decoder are included within the architecture of SegNet. As part of the encoder process, images are compressed and features are extracted using rectified linear units (ReLUs). Upon its completion, the decoder process restores the image. Due to the use of the same pooling layer as in the encoder process, spatial information is preserved during the decoding process. This feature of SegNet differentiates it from other FCNs. When image reconstruction is complete, the image is classified using a softmax function.The model results showed that SegNet outperformed U-Net in the classification of hardwood forest and bare land, but in all other items, U-Net showed a higher rate of accuracy than SegNet (Lee et al. 2020).

Conclusion

Convolutional Neural Networks (CNN) and Fully Convolutional Networks (FCN) are both state-of-the-art deep learning techniques, in order to detect deforestation. While CNNs, such as the Early Fusion (EF) method and the Siamese Network (S-CNN), struggle with the limitation of information loss. The FCN methods, U-Net and SegNet, bypass those limitations by an Encoder-Decoder architecture, that exchange the Dense Layer with more Convolutional Filters. All methods delivered promising results regarding the classification of areas suffering much deforestation. As deep learning is still an aspiring technology, especially in the remote sensing field, many large deep learning libraries such as Keras , last visited on 11.11.2022} or Tensorflow\footnote{\url{https://www.tensorflow.org/}, last visited on 11.11.2022} do not provide an implementation. Nevertheless using multi-band satellite imagery in combination with computer vision and deep learning methods will be a auspicious topic for future work.

The post Deep learning for deforestation detection. An insight into the state of the art. appeared first on Mobile USTP MKL.

Schwarzfahren wird einem in Wien zu leicht gemacht. Kontrollen kommen äußerst selten und einsteigen kann ich auch ohne gültigem Ticket. Es wird viel auf das Vertrauen der Benutzer*innen gesetzt, welche allerdings nicht oft genug auf den Kauf eines Tickets hingewiesen werden. Hier kommt mein Print2Mobile Initialprojekt zur Geltung. Auf den offizielle Entwertern der Wiener Linien, sollen QR-Codes angebracht werden, welche die Öffi-nutzenden Menschen an den Kauf eines Ticket erinnern soll. Kurz das Handy aus der Hosentasche ziehen, scannen und schon wird der Kauf eines Ticket per responsive Website möglich gemacht.

Technische Umsetzung

Weil meine bisherige Web-Programmierung schon einige Zeit her ist, wollte ich mir für dieses Projekt nicht all zu viel vornehmen und im Rahmen des realistischen bleiben. Ein Konstrukt mit HTML, Styles mit CSS und Animationen mit JavaScript. Zusätzlich habe ich auf Frameworks wie Bootstrap, Splide und AOS zurückgegriffen.

Es gelang mir ein guter Einstieg um wieder die Basics der Web-Programmierung aufzuschnappen.

Der Prototyp

Für den Prototypen (siehe unten) war es mir wichtig, den Use Case so realistisch wie möglich zu gestalten. Aus einem alten Karton, etwas Papier, Klebstoff und einem Edding, wurde ein selbstgebastelter Wiener Linien Entwerter wie man ihn aus jeder Ubahn-Station kennt. Ergänzt wurde er mit einem QR-Code plus Aufschrift “Kein Ticket?”.

Die Landing Page

Auf den Bildern ist die Landing Page zu sehen, welche unter it221515.students.fhstp.ac.at/wienmobil aufrufbar ist. Die Idee war es gleich auf den ersten Blick einen Bezug zum Prototypen herzustellen und dem/der User*in die Möglichkeit zu bieten das gewünschte Ticket zu kaufen. Weiter unten finden man noch eine Werbung der eigenen App von WienMobil. Im Footer gibt es die Möglichkeit zur Routenplanung und zum Ticketshop zu gelangen, sowie Hilfe anzufordern.

The post Print2Mobile – WienMobil appeared first on Mobile USTP MKL.