Re: Objekte und Zugriffs-Funktionen

[Jens-Peer Kuska <kuska@XXXXXXX.de>]

Hallo,

direkt von meiner SGI Octane,

mein Vorschlag mit

gr /. Graphics[Raster[m_,___],___] :> m

war darauf ausgerichtet m"oglichst wenig von der Datenstruktur zu
wissen.
Alternativ w"are

First /@ Cases[gr,_Raster,Infinity] 

oder "ahnliches m"oglich. Bei animierten GIF's gibst z. B. eine Liste
von Bildern.

Die in Mathematica 4 implementierten Imports[] f"ur Bitmaps haben einen
sehr
guten Grund. Mit der Version Raster[matrix,args__] kann Mathematica 4.0
n"amlich PackedArrays[] f"ur die Matrix verwenden, was z. b. bei der
Variante
die in meinem PNGBitmap-Package implementiert ist (noch) nicht geht weil 
dort eine PNGBitmap[] mit einer Matrix aus Pixel[r,g,b] zur"uckgegeben
wird. 
Ausserdem macht das  PNGBitmap-Paket kein Graphics[] um die Bitmap
sondern 
erweitert Graphics[] um ein einige Regeln f"ur PNGBitmap[]'s.

Weil bitmaps ja ziemlich gross sein k"onnen ist es auch ganz gut dass
PackedArrays[]
verwendet werden. Die Bitmaps werden auch dann noch gross genug, da
Mathematica ja
keine Byte kennt, also f"ur ein normales RGB Tripel gleich  3*32 Bit
drauf gehen statt
3 * 8. 

Die Variante mit dem Auslesen von Rot, Gr"un und Blau Anteil stimmt so
auch nur
f"ur RGB Bilder. Bei Bildern mit einer Palette erzeugt Import[] in der 
ColorFunction Option n"amlich eine Palette die erst die RGB Tripel
enth"alt
Also z. B bei einer Palette mit 3 Farben:

ColorFunction->(RGBColor[1,0,0],RGBColor[0,1,0],RGBColor[0,0,1]}[[#]] &)

als Option an das Raster[] Objekt. W"urden die Palette zu RGB-Tripeln
expandiert, 
kostet das n"amlich gleich dreimal soviel Speicher. Bei Graustufen
Bildern
ist es das Selbe.

Man muss also vorher wissen ob man eine

RGB Bitmap
Graustufen Bitmap
eine Bitmap mit Palette

Importiert, sonst ist es n"amlich nur an Hand der ColorFunction
m"oglich, das
heraus zubekommen. Wer allerdings weiss das er eine 1024 x 1024 Bitmap
in 
expandierter RGB Darstellung in den Speicher bekommt der kann
es mit

SetAttributes[MakeRGBMatrix,Listable]

MakeRGBMatrix[gr_] :=
    Module[{raster},
      raster = Cases[gr, _Raster, Infinity];
      raster = 
      raster /. Raster[m_?MatrixQ, args__, opt___?OptionQ] :> {m, 
            ColorFunction /. {opt}};
      raster = raster /. {m_?MatrixQ, cfun_} :> Map[cfun, m, {2}];
      First[raster /.  GrayLevel[g_] :> RGBColor[g, g, g]]
    ] 

probieren. Die Farbkan"ale lassen sich dann einfach mit

mat /. RGBColor[r_,_,_]:> GrayLevel[r]
mat /. RGBColor[_,g_,_]:> GrayLevel[g]
mat /. RGBColor[_,_,b_]:> GrayLevel[b]

trennen. Das sollte mit Palette-Bildern, RGB-Bildern und Graystufen
Bildern
funktionieren. Es sei aber gleich gesagt, dass man noch ein bischen
Speicher
nachr"usten sollte. Aus einer 8 x 8 Graustufen Bitmap mit 64 Byte werden
hier
n"amlich 1.5 kByte 8 x 8 x 3 (RGB) x 8 (double). Das ist nat"urlch bloss
24 mal
mehr - was tut man nicht alles f"ur die einheitliche Struktur, die
Kosten f"ur den
Overhead, den die RGBColor[] Objekte brauchen nicht, mit gerechnet. 

Zum Information Hiding kann ich nur sagen, dass es sich bei der
Datenverabeitung
gleich viel besser arbeitet, wenn man weiss *was* f"ur Daten man
"uberhaupt verarbeiten
will. Man beisst auch viel lieber in einen Apfel wenn man weiss,
das es kein Ziegelstein ist.

Die "expliziten Zugriffsfunktionen" sind eine exquisite Idee ..
Wenn ich z. B. aus einem RGB-Bild den Rot-Kanal mit einem 
Laplace-Filter
bearbeiten will dann ist das mit "expliziten Zugriffsfunktionen" und

Table[-4 GetRedChannel[bitmap,i,j] + GetRedChannel[bitmap,i-1,j] + 
                                     GetRedChannel[bitmap,i+1,j] +
                                     GetRedChannel[bitmap,i,j-1] + 
                                    
GetRedChannel[bitmap,i,j+1],{i,2,n-1},{j,2,m-1}]

nicht nur mit 5 Funktionsaufrufen pro Pixel erledigt (also 50000
Aufrufen bei einer 102 x 102
Bitmap) sondern auch viel viel "ubersichtlicher als

ListConvolve[{{ 0, 1, 0},
              { 1,-4, 1},
              { 0, 1, 0}},bitmap /. RGBColor[r_,_,_]:> r]


Nat"urlich kann man GetRedChannel[] noch besser machen in dem man ihm
nicht
das Attribute HoldFirst gibt, erstens kann man dann noch ein Pattern
angeben,
damit keine roten Farben in Ausdr"ucken wie Exp[-x^2]*x/2 gesucht
werden, zweitens
wird dann alles noch schneller, weil die Bitmap immer kopiert wird.

Das war jetzt ironisch gemeint, falls jemand zweifelt ;-)

Meine bevorzugte Methode mit einem minimalen Wissen "uber die
Datenstruktur
auszukommen sind (man ahnt es) Pattern[]. Mathematica ist darauf
getrimmt
Pattern[] zu vergleichen, deshalb ist das System so unglaublich genial.
Immer wenn ich Part[] benutzt habe, habe ich es fr"uher oder sp"ater
bereut.

Gruss
  Jens  

PS:Anscheinend wird  Show[datum] nicht immer verstanden, den z. B. 

Show[Date[]]

wird mit

Show::"gcomb": "An error was encountered in combining the graphics
objects in 
Show[{2000, 1, 31, 19, 40, 1}]."

 Show[{2000, 1, 31, 19, 40, 1}]

quitiert und nicht mit einem h"ubschen Kalenderblatt und launigen
Sinnspruch. 


> Absoluter Datenzugriff
> ----------------------
> 
> Diese Antwort kann nur jemand geben, der die _detaillierte Listenstruktur_ des
> Objektes
> 
>    gr="Graphics"[ Raster...
> 
> genau kennt, der also weiss, wie diese Listenstruktur in Bezug auf Dateninhalt
> und dessen Anordnung aufgebaut ist.
> 
> Erst dann kann man ueber die entsprechenden Listen-Indizes auf die gesuchten
> Daten zugreifen.
> 
> Das moechte ich hier als _absoluten Datenzugriff_ bezeichnen.
> 
> Information Hiding
> ------------------
> 
> Bei _abstrakten Datentypen_ aber unterscheidet man nach meinem Wissen zwischen
> der _eigentlichen Datenstruktur_ und den _Zugriffsfunktionen_, die auf diesen
> abstrakten Datentypen arbeiten.
> 
> Der Anwender muss somit nicht wissen,
> 
>   - _wie_ die Datenstruktur _aufgebaut_ ist,
>   - _wo_  die einzelnen Teile der Datenstruktur stehen,
>   - _wie_ genau man darauf _zugreift_ .
> 
> Information Hiding bei Mathematica
> ----------------------------------
> 
> Anscheinend verstehen Funktionen wie Show[ datum ] auch, welcher Datentyp vor-
> liegt und wie er zu behandeln ist.
> 
> Steht aber zu solchen Objekten wie einer Raster-Graphik auch eine _allgemeine
> Zugriffsfunktion_ zur Verfuegung, die etwa so aufgerufen wird :
> 
>     exportedData :=
>         ZugriffsFunction[ objectName,
>                           symbolicObjectPart,
>                           { listOfObjectPartIndices },
>                           furtherOptions
>                         ]                                   ?
> 
> Konkret etwa also :
> 
>    redPixelMatrix :=
>        ZugriffsFunction[ graphicObjectName,
>                          redPixel,
>                          { { x, 1, last }, { y, 1, last } }
>                        ]                                    .
> 
> Schlussbemerkung
> ----------------
> 
> Leider sehe ich keine allgemeine Antwort auf meine Frage; vielleicht gibt es
> trotzdem eine allgemeine Antwort !
> 
> Fuer eine Stellungnahme waere ich dankbar !
> 
> Mit freundlichen Gruessen,
> 
> Gunter Woysch                            File : mail_00/dmug_000131_email_to