[JS]
[DE]
[PLUGIN] popup.plugin
[PLUGIN] lvm.plugin
[PLUGIN] file.plugin
[PLUGIN] pixels.plugin
[PLUGIN] math.plugin
[PLUGIN] button.plugin

[TITLE] Übung 4 zu Verteilte und Parallele Programmierung: Parallele Zelluläre Automaten (Teil 2, Bildverarbeitung)
[AUTHOR] PD Stefan Bosse

[TOC]

[VERSION] 5.2024

[USE] plot
[USE] math

[FUN]
```js
// PIXELS caworld handler and LUA event handler (simu:draw)
window.caworld={
}
// LUA event handler (via @event messages)
lvmShells.event = function (ev) {
  console.log('lvmShells.event',ev)
  if (ev=='grid') {
    // grid was updated via @data messages from lua
    // must conform with caluaP.lua!
    // update PIXELS world here
    if (PIXELS.rendered('myworld')) PIXELS.update('myworld',lvmShells.grid);
    else if (lvmShells.model) {
      console.log(lvmShells.model)
      // create simulation world
      caworld.grid=lvmShells.grid;
      if (lvmShells.model.palette) lvmShells.model.palette.unshift('white'); // LUA color index starts with 1!
      for(var p in lvmShells.model) window.caworld[p]=lvmShells.model[p];
      PIXELS.create('myworld',{handler:'caworld',index:'myworld'})
    }
  }
}
```

# Übung 4: Parallele Zelluläre Automaten mit Lua (Bildverarbeitung)

## Vorbereitung

- Es wird die parallele LuaJit VM *lvm* für das jeweilige eigene Betriebssystem benötigt
  + Momentan steht *lvm* für die Betriebssysteme *Linux 32bit*, *Linux 64bit*, *Solaris 32bit*, und *Windows 32bit* zur Verfügung. Da Microsoft Windows zu keinem guten Informatikkonzept kompatibel ist kann es dort zu funktionalen Abweichungen und Einschränkungen von *lvm* kommen → [lvm](http://edu-9.de/Lehre/vpp3k)
  + Lua/Csp Programme können direkt von der Konsole ausgeführt werden:
```
# lvm myprog.lua
```
  + Die Programme (oder Teile davon) können ebenso in diesem Notebook ausgeführt werden wenn *lvm* mit einem WEB Shell Wrapper gestartet wird (lokaler Rechner, Konsole):
```
# lvm weblvm.lua
Service thread 2 started.
[2@1592562880] HTTP server (2) listening to http://0.0.0.0:4610
Monitor thread 4 started.
[4@1592562880] HTTP server (4) listening to http://0.0.0.0:4611
```

- **Zusätzlich werden im gleichen Verzeichnis benötigt**:
  + `caluaP.lua`
  + `weblvm.lua`
  + `png-plugin.lua`
  
## Lua Code Ausführen

## ZA Simulation

- Die Simulation bzw, die Berechnung des ZA wird direkt über die (p)lvm durchgeführt
- Die ZA Welt kann in Partitionen unterteilt werden
- Jede Partition wird in einem eigenen Worker Prozess mit einer eigenen VM Instanz berechnet
- Verteilung und Zusammenführung durch einen Master Prozess
- Anstelle der Klasse *CA.Simulation* wird nun die Klasse *CA.SimulationPar* verwendet

>! Wichtig: Da Shared Memory verwendet wird (intern über ein SM-Matrix Objekt) dürfen die Zustandsdatenvariablen der Zellen nur noch vom Typ *number* sein (Integer, Float)!

- Boolesche Ausdrücke müssen in numerische Werte kodiert werden, z.B. mit der `conditional(bexpr,vtrue,vfalse)` Hilfsfunktion.

- Weiterhin ist bei paralleler partitionierter Berechnung die randomsierte Initialisierung abzuändern. Es sollte eine globale geteilte Matrix für alle Partitionen verwendet werden, die mit Pseudozufallszahlen in einem Prozess berechnet wird.
  + Grund: In der Lua VM/lvm startet der Pseudozufallszahlengenerator (*math.random*) immer mit der gleichen Sequenz!
  + Würde man daher die randomisierte Zelleninitialisierung in jedem Partitionsprozess (jeweils eine Lua VM Instanz) getrennt berechnen erhielte man in allen Partitionen das gleiche Startmuster!

### Eine Partition

- Rein sequenzielle Berechnung, aber schon in einem separaten Worker Prozess (wie *CA.Simulation*).
- Wichtig: Globale Initialisierung der Zellen (über verteilbare Modelldaten *data*)

### Mutiple Partitionen

- Jede Partition wird sequenziell, aber alle Partitionen parallel ausgeführt
- Wichtig: Globale Initialisierung der Zellen (über verteilbare Modelldaten *data*)
- Simulationsschritte sind synchronisiert

#### Unterstütze Paritionsformate

```ascii
+-----+   +-----+  +-----+-----+
|     |   |  1  |  |  1  |  2  |
|  1  |   +-----+  +-----+-----+
|     |   |  2  |  |  3  |  4  |
+-----+   +-----+  +-----+-----+

+-----+-----+    +-----+-----+    +-----+-----+-----+-----+
|  1  |  2  |    |  1  |  2  |    |  1  |  2  |  3  |  4  |
+-----+-----+    +-----+-----+    +-----+-----+-----+-----+
|  3  |  4  |    |  3  |  4  |    |  5  |  6  |  7  |  8  |
+-----+-----+    +-----+-----+    +-----+-----+-----+-----+
|  5  |  6  |    |  5  |  6  |    |  9  | 10  | 11  | 12  |
+-----+-----+    +-----+-----+    +-----+-----+-----+-----+
                 |  7  |  8  |    | 13  | 14  | 15  | 16  |
                 +-----+-----+    +-----+-----+-----+-----+
```

>! Wichtig: Die Paritionierung in x- und y-Richtung muss ganzahlig sein, d.h. die Größe der Automatenwelt muss durch die Anzahl Spalten und Zeilen ganzzahlig teilbar sein!

### Sensoren und Aktoren

- Der Zustand einer Zelle besteht aus einer oder mehreren Variablen

- I.A. ist eine Variable ein Sensor, der von der Nachbarzellen gelesen wird

- I.A. ist eine andere Variable der zustandsbestimmende Aktor einer Zelle, die auch die Farbe einer Zelle bestimmt

- Die Nachbarzellen sind durch das Objekt *self.neighbors* erreichbar (direkt mit dem Shared Memory Modell, indirekt durch get/set Methoden über Kommunikationskanäle im Distributed Memory Modell). Die Felder und relativen Positionen sind wie folgt gezeigt:

```lua#box
if model.neighbors == 4 then
    -- Neumann
    self.neighbors = {
      left    = {-1,0},
      right   = {1,0},
      bottom  = {0,1},
      top     = {0,-1}
    }
elseif model.neighbors == 8 then
    -- Moore
    self.neighbors = {
      left        = {-1,0},
      right       = {1,0},
      bottom      = {0,1},
      top         = {0,-1},
      topleft     = {-1,-1},
      topright    = {1,-1},
      bottomleft  = {-1,1},
      bottomright = {1,1}
    }
end
```

## Bilddaten

[LVM] Bilddaten und Rauschngenerator { lines:10 }
```lua
require "Csp"
require "png-plugin"
img = pngImage ("catest.png");
-- Shared data image matrix (rows/columns muß mit CA Modell übereinstimmen)
data  = Matrix:new({100,100});
data0 = Matrix:new({100,100});
target = Matrix:new({100,100});
-- Bild wird in die shared data matrix kopiert (pixel={0,1})
img:toBuffer(data0,"invbinary",128)
img:toBuffer(data,"invbinary",128)
print(img.width,img.height)
-- Rauschen hinzufügen
local unequal=0
for row=1,img.height do
  for col=1,img.width do
    -- 10% Rauschn == 0.1
    if math.random() < 0.1 then
      unequal = incr(unequal)
      if data:read(col,row) > 0 then
        data:write(0,col,row)
      else
        data:write(1,col,row)
      end
    end
  end
end
print(unequal)
```

## A. Rauchunterdrückung: Nachbarschaftsglättung

- Sehr naiver Rauschfilter durch Nachbarschaftsglättung. Wichtig: Binäre Bilder erlauben Grauwertinterpolation!

- Ein Pixelwert wird durch die "Mehrheit" der Nachbarschaft gsetzt (1/0)

### Zellenmodell

- Das Zellenmodell hat eine zusätzliche *after* Aktivität die aktualisierte Ergebnisse der Bildbearbeitung in einer geteilten Matrix *target* speichert.

[LVM] A. Das Zellenmodell { lines:10 }
```lua
require "caluaP"
-- Create a new individual cell class 
cell=CA.Cell({
  name = "pixel",
  monitor = true,
  state = { pixel = 0, wasPixel = 0 }
})
function cell:before (x,y)
  self.wasPixel = self.pixel
end
function cell:activity (x,y)
  -- Nur 1-Pixel werden zunächst bewertet
  local surrounding = self:ask(self.neighbors, 'count', 'wasPixel', 1)
  self.pixel=conditional(surrounding >= self.threshold,1,0)
  -- Eigener Code hier...
end
function cell:after (x,y)
  self.data.target:write(self.pixel,x,y)
end
function cell:initialize (x,y)
  self.pixel = self.data.image:read(x,y)
end
function cell:color ()
  return conditional(self.pixel==1,2,1)
end
```

### Simulationsmodell

[LVM] A. Das Welt- und Simulationsmodell { lines:10 }
```lua
model = {
  rows = 100,      -- N
  columns = 100,   -- N
  size = 4,
  neighbors = 8,
  palette = {'white','red'},
  partitions = 1,
  scheduler = 'RANDOM',  -- two phase all before; all process
  cell = cell,
  parameter = {
    -- Für Nachbarschaftsglättung
    threshold = 6,
  },
  data = {
    -- must be consistent with rows/cols=N!
    image = data,
    target = target
  },
  start = { name = 'pixel' }
}
```

## B. Rauchunterdrückung: Regel- und Musterbasiert

- Lese [Rosin,2002](http://edu-9.de/uploads/articles/Rosinmanuscript2.pdf)

- Versuche die im Artikel gezeigten Muster zur Rauschunterdrückung in folgende Code einzubauen. Teste den Algorithmus

### Zellenmodell

- Das Zellenmodell hat eine zusätzliche *after* Aktivität die aktualisierte Ergebnisse der Bildbearbeitung in einer geteilten Matrix *target* speichert.

- In der Aktivitätsfunktion müssen alle defnierten Muster der Nachbarschaftszellenpixel geprüft werden. Zellen am Weltrand (mit weniger als 8 Nachbarn) werden noch nicht berücksichtigt.

- Wenn ein Muster gefunden wurde wird die Regel des zustandsübergangs *pixel*~0~ → *pixel* angewendet, d.h., die regel wird nur angewendet wenn *wasPixel*=*pixel*~0~ (Optimierung: vorher die Bedingung abfragen)

[LVM] B. Das Zellenmodell { lines:10 }
```lua
require "caluaP"
-- Create a new individual cell class 
cell=CA.Cell({
  name = "pixel",
  monitor = true,
  state = { pixel = 0, wasPixel = 0 }
})
function cell:before (x,y)
  self.wasPixel = self.pixel
end
function cell:activity (x,y)
  -- Parameterreihenfolge:
  local header = self.data.rules[1];
  local test,equal = 0,0
  for ri = 2,#self.data.rules do
    local equal=0
    local rule = self.data.rules[ri]
    -- Muster testen (oder zuerst die Übergangsbedingung testen)
    for ki = 1,8 do
      if self.neighbors[header[ki]] ~= nil and
         self.neighbors[header[ki]].wasPixel == rule[ki] then
        equal=incr(equal)
      end
    end
    -- Muster gefunden?
    -- pixel0  == rule[9]
    -- pixel   == rule[10]
    if equal==8 then
      if rule[9] == self.wasPixel then
        self.pixel = rule[10];
      end
    end
  end
end
function cell:after (x,y)
  self.data.target:write(self.pixel,x,y)
end
function cell:initialize (x,y)
  self.pixel = self.data.image:read(x,y)
end
function cell:color ()
  return conditional(self.pixel==1,2,1)
end
```
### Musterregeln

- Eine Regel besteht aus einer Übergangsbedingung *pixel*~0~ → *pixel* und dem Nachbarschaftsmuster

- Alle Werte sind in einem Array enthalten

- Die erste Zeile der Regeltabelle definiert die Reihenfolge und Namen der Regelwerte

[LVM] B. Liste von Musterregeln (Nachbarn) { lines:10 }
```lua
rules = {
-- Index 1-8: Nachbarzellen, Index 9: alter Pixelwert (aktuelle Zelle)
--                           Index 10: neuer Pixelwert
{'topleft','top','topright',
 'left',         'right',
 'bottomleft','bottom','bottomright',
 'pixel0','pixel'},
{0,0,0,0,0,0,0,0, 1,0}  -- rule 1
-- Weitere Regeln hier...
}
```

### Simulationsmodell

[LVM] B. Das Welt- und Simulationsmodell { lines:10 }
```lua
model = {
  rows = 100,      -- N
  columns = 100,   -- N
  size = 4,
  neighbors = 8,
  palette = {'white','red'},
  partitions = 1,
  scheduler = 'RANDOM',  -- two phase all before; all process
  cell = cell,
  parameter = {
  },
  data = {
    -- must be consistent with rows/cols=N!
    image = data,
    target = target,
    rules = rules,
  },
  start = { name = 'pixel' }
}
```

## Simulation erzeugen

>! Fehler während der Simulation werden **hier** angezeigt. Nach Erzeugung des Simulators das Konsolenfenster leeren!

[LVM] Den Simulator erzeugen { lines:10 }
```lua
model.partitions=1;
simulator = CA.SimulationPar:new(model);
simulator:draw();
```

---

## Simulation/Ausführung

- Der Aufruf der `simulator:draw` Methode überträgt das aktuelle Zellenbild an das Notebook wo es im nachfolgenden Fenster entsprechend der Farbpalette dargestellt wird.

- Falls die Simulation "hängt", den Stopp Knopf drücken (und Konsole aktualisieren bis INTR meldung kommt)

[PIXELS] ZA World { handler:'caworld'; index:'myworld' }

[LVM] Die Simulation { lines:10 }
```lua
local t0=luv.milli()
local steps=1
for i=1,steps do
  print('Step '..i)
  simulator:step()
end
local t1=luv.milli()
print((t1-t0)/steps,'ms/step')
-- update visual world in notebook
simulator:draw()
```

[LVM] Simulation terminieren{ lines:10 }
```lua
simulator:stop()
simulator=nil
```
## Evaluierung

[LVM] Bestimmung der fehlerhaften Pixel { lines:10 }
```lua
local unequal=0;
for row=1,model.rows do
  for col=1,model.columns do
    if model.data.target:read(col,row) ~= data0:read(col,row) then
      unequal = incr(unequal)
    end
  end
end
print(unequal)
```

### Muster

## Aufgaben

- Alle Aufgaben werden mit ZA Größe 100 × 100 Zellen bearbeitet
- Zunächst *P*=1 (dann mit *P*=2 und *P*=4 vergleichen)

[EXERCISE]

1. Implementiere den  Algorithmus (A). Verwende den *RANDOM* Scheduler. Simuliere schrittweise (Einzelschritt). Wie verändert sich das Ergebnis (Anzahl fehlerhafter Pixel) mit der Threshold und den Anzahl von Schritten (es kann auch zur Destruktion des Bidles bei weiteren Schritten kommen).

[INPUT]

2. Erweitere den Algorithmus (A) mit einer Regel für 0-Pixel (*wasPixel*==0). Verändert sich die Qualität des Algorithmus? Notiere die Rechenzeit für einen Simulationsschritt.

[INPUT]

3. Implementiere den  Algorithmus (B). Verwende den *RANDOM* Scheduler. Simuliere schrittweise (Einzelschritt). Füge weitere Regeln hinzu (siehe Artikel) und untersuche die Qualität (Anteil fehlerhafter Pixel). Dokumentiere für jeden Regelsatz das Ergebnis (Fehlerrate im Bild) mit dem dazugehörigen Regelsatz (als 0/1 Vektor). Notiere die Rechenzeit für einen Simulationsschritt.

[INPUT]

[EXERCISE]

---

[BUTTON] Hilfe { action:post; label:Absenden; style:"color:red" }
```
{
  url:function (url) { return url.indexOf('https')==0?'https://edu-9.de:28889':'http://edu-9.de:28888'},
  // url:'localhost:28888',
  form:['Name','Email','Pin','Frage'],
  email:{from:'$Email', to:'sbosse@uni-bremen.de', name:'$Name'},
  subject:'Hilfe Kurs ML $TITLE',
  message:'$Name: $Frage',
  attachments:[{filename:'$FILE.json',content:'$CODE'}],
  pin:1827,
}
```

[BUTTON] Einreichung (Assignment #2024-95956) { action:post; label:Absenden; style:"color:green" }
```
{
  url:function (url) { return url.indexOf('https')==0?'https://edu-9.de:28889':'http://edu-9.de:28888'},
  // url:'localhost:28888',
  form:['Name','Email','Pin','Kommentar'],
  submit: { from:'$Email', to:'sbosse@uni-bremen.de' },
  assignment:'2024-95956',
  name : '$Name',
  comment : '$Kommentar',
  attachments:[{filename:'$FILE.json',content:'$CODE'}],
  pin:1827,
}
```

[BUTTON] Prüfen { action:post; label:Laden; style:"color:browm" }
```
{
  url:function (url) { return url.indexOf('https')==0?'https://edu-9.de:28889':'http://edu-9.de:28888'},
  // url:'localhost:28888',
  form:['ID','Pin'],
  load: { id:'$ID' },
  pin:[1827,9223],
}
```

[BUTTON] Bewerten (Lehrer) { action:post; label:Absenden; style:"color:blue" }
```
{
  url:function (url) { return url.indexOf('https')==0?'https://edu-9.de:28889':'http://edu-9.de:28888'},
  // url:'localhost:28888',
  form:['ID','Marking','Pin','Remarks'],
  submit: { id:'$ID', from:'sbosse@uni-bremen.de', name:'$Name' },
  marks : '$Marking',
  remarks : '$Remarks',
  attachments:[{filename:'$FILE.json',content:'$CODE'}],
  pin:9223,
}
```

---

Inhalt.

Übung 4: Parallele Zelluläre Automaten mit Lua (Bildverarbeitung)

Vorbereitung

Lua Code Ausführen

ZA Simulation

Eine Partition

Mutiple Partitionen

Unterstütze Paritionsformate

Sensoren und Aktoren

Bilddaten

A. Rauchunterdrückung: Nachbarschaftsglättung

Zellenmodell

Simulationsmodell

B. Rauchunterdrückung: Regel- und Musterbasiert

Zellenmodell

Musterregeln

Simulationsmodell

Simulation erzeugen

Simulation/Ausführung

Evaluierung

Muster

Aufgaben

Übung 4: Parallele Zelluläre Automaten mit Lua (Bildverarbeitung)

Vorbereitung

Es wird die parallele LuaJit VM lvm für das jeweilige eigene Betriebssystem benötigt
- Momentan steht lvm für die Betriebssysteme Linux 32bit, Linux 64bit, Solaris 32bit, und Windows 32bit zur Verfügung. Da Microsoft Windows zu keinem guten Informatikkonzept kompatibel ist kann es dort zu funktionalen Abweichungen und Einschränkungen von lvm kommen → lvm
- Lua/Csp Programme können direkt von der Konsole ausgeführt werden:
```
# lvm myprog.lua
```
- Die Programme (oder Teile davon) können ebenso in diesem Notebook ausgeführt werden wenn lvm mit einem WEB Shell Wrapper gestartet wird (lokaler Rechner, Konsole):
```
# lvm weblvm.lua
Service thread 2 started.
[2@1592562880] HTTP server (2) listening to http://0.0.0.0:4610
Monitor thread 4 started.
[4@1592562880] HTTP server (4) listening to http://0.0.0.0:4611
```
Zusätzlich werden im gleichen Verzeichnis benötigt:
- caluaP.lua
- weblvm.lua
- png-plugin.lua

Lua Code Ausführen

ZA Simulation

Die Simulation bzw, die Berechnung des ZA wird direkt über die (p)lvm durchgeführt
Die ZA Welt kann in Partitionen unterteilt werden
Jede Partition wird in einem eigenen Worker Prozess mit einer eigenen VM Instanz berechnet
Verteilung und Zusammenführung durch einen Master Prozess
Anstelle der Klasse CA.Simulation wird nun die Klasse CA.SimulationPar verwendet

Wichtig: Da Shared Memory verwendet wird (intern über ein SM-Matrix Objekt) dürfen die Zustandsdatenvariablen der Zellen nur noch vom Typ number sein (Integer, Float)!

Boolesche Ausdrücke müssen in numerische Werte kodiert werden, z.B. mit der conditional(bexpr,vtrue,vfalse) Hilfsfunktion.
Weiterhin ist bei paralleler partitionierter Berechnung die randomsierte Initialisierung abzuändern. Es sollte eine globale geteilte Matrix für alle Partitionen verwendet werden, die mit Pseudozufallszahlen in einem Prozess berechnet wird.
- Grund: In der Lua VM/lvm startet der Pseudozufallszahlengenerator (math.random) immer mit der gleichen Sequenz!
- Würde man daher die randomisierte Zelleninitialisierung in jedem Partitionsprozess (jeweils eine Lua VM Instanz) getrennt berechnen erhielte man in allen Partitionen das gleiche Startmuster!

Eine Partition

Rein sequenzielle Berechnung, aber schon in einem separaten Worker Prozess (wie CA.Simulation).
Wichtig: Globale Initialisierung der Zellen (über verteilbare Modelldaten data)

Mutiple Partitionen

Jede Partition wird sequenziell, aber alle Partitionen parallel ausgeführt
Wichtig: Globale Initialisierung der Zellen (über verteilbare Modelldaten data)
Simulationsschritte sind synchronisiert

Unterstütze Paritionsformate

┌─────┐   ┌─────┐  ┌─────┬─────┐                           
│     │   │  1  │  │  1  │  2  │                           
│  1  │   ├─────┤  ├─────┼─────┤                           
│     │   │  2  │  │  3  │  4  │                           
└─────┘   └─────┘  └─────┴─────┘                           
                                                           
┌─────┬─────┐    ┌─────┬─────┐    ┌─────┬─────┬─────┬─────┐
│  1  │  2  │    │  1  │  2  │    │  1  │  2  │  3  │  4  │
├─────┼─────┤    ├─────┼─────┤    ├─────┼─────┼─────┼─────┤
│  3  │  4  │    │  3  │  4  │    │  5  │  6  │  7  │  8  │
├─────┼─────┤    ├─────┼─────┤    ├─────┼─────┼─────┼─────┤
│  5  │  6  │    │  5  │  6  │    │  9  │ 10  │ 11  │ 12  │
└─────┴─────┘    ├─────┼─────┤    ├─────┼─────┼─────┼─────┤
                 │  7  │  8  │    │ 13  │ 14  │ 15  │ 16  │
                 └─────┴─────┘    └─────┴─────┴─────┴─────┘

Wichtig: Die Paritionierung in x- und y-Richtung muss ganzahlig sein, d.h. die Größe der Automatenwelt muss durch die Anzahl Spalten und Zeilen ganzzahlig teilbar sein!

Sensoren und Aktoren

Der Zustand einer Zelle besteht aus einer oder mehreren Variablen
I.A. ist eine Variable ein Sensor, der von der Nachbarzellen gelesen wird
I.A. ist eine andere Variable der zustandsbestimmende Aktor einer Zelle, die auch die Farbe einer Zelle bestimmt
Die Nachbarzellen sind durch das Objekt self.neighbors erreichbar (direkt mit dem Shared Memory Modell, indirekt durch get/set Methoden über Kommunikationskanäle im Distributed Memory Modell). Die Felder und relativen Positionen sind wie folgt gezeigt:

if model.neighbors == 4 then
    -- Neumann
    self.neighbors = {
      left    = {-1,0},
      right   = {1,0},
      bottom  = {0,1},
      top     = {0,-1}
    }
elseif model.neighbors == 8 then
    -- Moore
    self.neighbors = {
      left        = {-1,0},
      right       = {1,0},
      bottom      = {0,1},
      top         = {0,-1},
      topleft     = {-1,-1},
      topright    = {1,-1},
      bottomleft  = {-1,1},
      bottomright = {1,1}
    }
end

┌──────────┬──────────┬──────────┬────▶ x
│          │          │          │       
│ topleft  │   top    │ topright │       
│          │          │          │       
├──────────┼──────────┼──────────┤       
│          │          │          │       
│ left     │  pixel   │ right    │       
│          │          │          │       
├──────────┼──────────┼──────────┤       
│          │          │          │       
│ bottom-  │  bottom  │ bottom-  │       
│ left     │          │ right    │       
├──────────┴──────────┴──────────┘       
│                                        
│                                        
▼  y

Bilddaten

Bilddaten und Rauschngenerator

require "Csp"
require "png-plugin"
img = pngImage ("catest.png");
-- Shared data image matrix (rows/columns muß mit CA Modell übereinstimmen)
data  = Matrix:new({100,100});
data0 = Matrix:new({100,100});
target = Matrix:new({100,100});
-- Bild wird in die shared data matrix kopiert (pixel={0,1})
img:toBuffer(data0,"invbinary",128)
img:toBuffer(data,"invbinary",128)
print(img.width,img.height)
-- Rauschen hinzufügen
local unequal=0
for row=1,img.height do
  for col=1,img.width do
    -- 10% Rauschn == 0.1
    if math.random() < 0.1 then
      unequal = incr(unequal)
      if data:read(col,row) > 0 then
        data:write(0,col,row)
      else
        data:write(1,col,row)
      end
    end
  end
end
print(unequal)

▸

◼

✗

↻

≡

A. Rauchunterdrückung: Nachbarschaftsglättung

Sehr naiver Rauschfilter durch Nachbarschaftsglättung. Wichtig: Binäre Bilder erlauben Grauwertinterpolation!
Ein Pixelwert wird durch die "Mehrheit" der Nachbarschaft gsetzt (1/0)

Zellenmodell

Das Zellenmodell hat eine zusätzliche after Aktivität die aktualisierte Ergebnisse der Bildbearbeitung in einer geteilten Matrix target speichert.

A. Das Zellenmodell

require "caluaP"
-- Create a new individual cell class 
cell=CA.Cell({
  name = "pixel",
  monitor = true,
  state = { pixel = 0, wasPixel = 0 }
})
function cell:before (x,y)
  self.wasPixel = self.pixel
end
function cell:activity (x,y)
  -- Nur 1-Pixel werden zunächst bewertet
  local surrounding = self:ask(self.neighbors, 'count', 'wasPixel', 1)
  self.pixel=conditional(surrounding >= self.threshold,1,0)
  -- Eigener Code hier...
end
function cell:after (x,y)
  self.data.target:write(self.pixel,x,y)
end
function cell:initialize (x,y)
  self.pixel = self.data.image:read(x,y)
end
function cell:color ()
  return conditional(self.pixel==1,2,1)
end

▸

◼

✗

↻

≡

Simulationsmodell

A. Das Welt- und Simulationsmodell

model = {
  rows = 100,      -- N
  columns = 100,   -- N
  size = 4,
  neighbors = 8,
  palette = {'white','red'},
  partitions = 1,
  scheduler = 'RANDOM',  -- two phase all before; all process
  cell = cell,
  parameter = {
    -- Für Nachbarschaftsglättung
    threshold = 6,
  },
  data = {
    -- must be consistent with rows/cols=N!
    image = data,
    target = target
  },
  start = { name = 'pixel' }
}

▸

◼

✗

↻

≡

B. Rauchunterdrückung: Regel- und Musterbasiert

Lese Rosin,2002
Versuche die im Artikel gezeigten Muster zur Rauschunterdrückung in folgende Code einzubauen. Teste den Algorithmus

Zellenmodell

Das Zellenmodell hat eine zusätzliche after Aktivität die aktualisierte Ergebnisse der Bildbearbeitung in einer geteilten Matrix target speichert.
In der Aktivitätsfunktion müssen alle defnierten Muster der Nachbarschaftszellenpixel geprüft werden. Zellen am Weltrand (mit weniger als 8 Nachbarn) werden noch nicht berücksichtigt.
Wenn ein Muster gefunden wurde wird die Regel des zustandsübergangs pixel₀ → pixel angewendet, d.h., die regel wird nur angewendet wenn wasPixel=pixel₀ (Optimierung: vorher die Bedingung abfragen)

B. Das Zellenmodell

require "caluaP"
-- Create a new individual cell class 
cell=CA.Cell({
  name = "pixel",
  monitor = true,
  state = { pixel = 0, wasPixel = 0 }
})
function cell:before (x,y)
  self.wasPixel = self.pixel
end
function cell:activity (x,y)
  -- Parameterreihenfolge:
  local header = self.data.rules[1];
  local test,equal = 0,0
  for ri = 2,#self.data.rules do
    local equal=0
    local rule = self.data.rules[ri]
    -- Muster testen (oder zuerst die Übergangsbedingung testen)
    for ki = 1,8 do
      if self.neighbors[header[ki]] ~= nil and
         self.neighbors[header[ki]].wasPixel == rule[ki] then
        equal=incr(equal)
      end
    end
    -- Muster gefunden?
    -- pixel0  == rule[9]
    -- pixel   == rule[10]
    if equal==8 then
      if rule[9] == self.wasPixel then
        self.pixel = rule[10];
      end
    end
  end
end
function cell:after (x,y)
  self.data.target:write(self.pixel,x,y)
end
function cell:initialize (x,y)
  self.pixel = self.data.image:read(x,y)
end
function cell:color ()
  return conditional(self.pixel==1,2,1)
end

▸

◼

✗

↻

≡

Musterregeln

Eine Regel besteht aus einer Übergangsbedingung pixel₀ → pixel und dem Nachbarschaftsmuster
Alle Werte sind in einem Array enthalten
Die erste Zeile der Regeltabelle definiert die Reihenfolge und Namen der Regelwerte

B. Liste von Musterregeln (Nachbarn)

rules = {
-- Index 1-8: Nachbarzellen, Index 9: alter Pixelwert (aktuelle Zelle)
--                           Index 10: neuer Pixelwert
{'topleft','top','topright',
 'left',         'right',
 'bottomleft','bottom','bottomright',
 'pixel0','pixel'},
{0,0,0,0,0,0,0,0, 1,0}  -- rule 1
-- Weitere Regeln hier...
}

▸

◼

✗

↻

≡

Simulationsmodell

B. Das Welt- und Simulationsmodell

model = {
  rows = 100,      -- N
  columns = 100,   -- N
  size = 4,
  neighbors = 8,
  palette = {'white','red'},
  partitions = 1,
  scheduler = 'RANDOM',  -- two phase all before; all process
  cell = cell,
  parameter = {
  },
  data = {
    -- must be consistent with rows/cols=N!
    image = data,
    target = target,
    rules = rules,
  },
  start = { name = 'pixel' }
}

▸

◼

✗

↻

≡

Simulation erzeugen

Fehler während der Simulation werden hier angezeigt. Nach Erzeugung des Simulators das Konsolenfenster leeren!

Den Simulator erzeugen

model.partitions=1;
simulator = CA.SimulationPar:new(model);
simulator:draw();

▸

◼

✗

↻

≡

Simulation/Ausführung

Der Aufruf der simulator:draw Methode überträgt das aktuelle Zellenbild an das Notebook wo es im nachfolgenden Fenster entsprechend der Farbpalette dargestellt wird.
Falls die Simulation "hängt", den Stopp Knopf drücken (und Konsole aktualisieren bis INTR meldung kommt)

ZA World

▸

✗

Die Simulation

local t0=luv.milli()
local steps=1
for i=1,steps do
  print('Step '..i)
  simulator:step()
end
local t1=luv.milli()
print((t1-t0)/steps,'ms/step')
-- update visual world in notebook
simulator:draw()

▸

◼

✗

↻

≡

Simulation terminieren

simulator:stop()
simulator=nil

▸

◼

✗

↻

≡

Evaluierung

Bestimmung der fehlerhaften Pixel

local unequal=0;
for row=1,model.rows do
  for col=1,model.columns do
    if model.data.target:read(col,row) ~= data0:read(col,row) then
      unequal = incr(unequal)
    end
  end
end
print(unequal)

▸

◼

✗

↻

≡

Muster

Aufgaben

Alle Aufgaben werden mit ZA Größe 100 × 100 Zellen bearbeitet
Zunächst P=1 (dann mit P=2 und P=4 vergleichen)

Aufgabe.

Implementiere den Algorithmus (A). Verwende den RANDOM Scheduler. Simuliere schrittweise (Einzelschritt). Wie verändert sich das Ergebnis (Anzahl fehlerhafter Pixel) mit der Threshold und den Anzahl von Schritten (es kann auch zur Destruktion des Bidles bei weiteren Schritten kommen).

Erweitere den Algorithmus (A) mit einer Regel für 0-Pixel (wasPixel==0). Verändert sich die Qualität des Algorithmus? Notiere die Rechenzeit für einen Simulationsschritt.

Implementiere den Algorithmus (B). Verwende den RANDOM Scheduler. Simuliere schrittweise (Einzelschritt). Füge weitere Regeln hinzu (siehe Artikel) und untersuche die Qualität (Anteil fehlerhafter Pixel). Dokumentiere für jeden Regelsatz das Ergebnis (Fehlerrate im Bild) mit dem dazugehörigen Regelsatz (als 0/1 Vektor). Notiere die Rechenzeit für einen Simulationsschritt.

Hilfe

Einreichung (Assignment #2024-95956)

Prüfen

Bewerten (Lehrer)

Created by the NoteBook Compiler Ver. 1.27.2 (c) Dr. Stefan Bosse (Wed May 15 2024 11:10:09 GMT+0200 (CET))