Schnittstelle für 2D-Skalarfeld

[EccoBravo]

Hallo,

Ich schreibe ein Projekt, in dem ich Bilder (2D-Skalarfelder aus verschiewdenen Komponenten) voneinander subtrahiere und andere Dinge damit mache.

//////////////////////////////////////////////////////////////////////////////////////

Ich habe mir schon vor langer Zeit eine Komponente KA
zur Darstellung eines Grauwertbildes von einem 2D-Skalarfeld gemacht.
Diese Komponente KA bringt mir einen Typ für das Skalarfeld TA mit
(aber dynamisch undimensioniert).

//+++++++++++++++++++++++++
// in Komponente A 
type 
    TA = array of array of single; 
    TKA = Class(...); 
        procedure XYZ(F:TA) 
        ....
var 
    A : TA; 
//+++++++++++++++++++++++

Diesen Typ verwende ich auch zum Erzeugen von Instanzen im Hauptprogramm,
und dimensioniere dort auch diese.

//++++++++++++++++++++++
// im Hauptprogramm 
uses KA; 
type 
    AB : TA; 
implementation 
    SetLength(AB,512,512); 
    KA1.XYZ(AB) 
    .... 
//+++++++++++++++++++++

Bislang habe ich im Hauptprogramm die Dimension dieses 2D-Skalarfeldes
an die besagte Komponente, zwecks Dimensionierung dort, weitergegeben.

Nun habe ich aber auch eine 2. Komponente KB, die etwas anderes macht als die erstgenannte Komponente KA.
Auch diese Komponente liefert ein dynamisches 2D-Skalarfeld TB.

//++++++++++++++++++++ 
// in Komponente B 
type 
    TB = array of array of single; 
    TKB = Class(...); 
        procedure XYZ(F:TB) 
        .....
var 
    B : TB; 
    ....
//++++++++++++++++++

Im Hauptprogramm sollen nun die Skalarfelder der beiden Komponenten KA und KB zusammen passen.

//++++++++++++++++++
// im Hauptprogramm 
uses KA, KB; 
type 
    AB : TA; 
implementation 
    SetLength(AB,512,512);  //Wunsch: diese Dimens. sollte auch in den Komponenten 
                            //gelten! 

    KA1.XYZ(AB); 
    KB1.XYZ(AB); 
    .... 
//++++++++++++++++

Natürlich geht das so nicht, wie ich es eben geschrieben habe, es ist nur zur Problemveranschaulichung.

Das Ganze riecht meiner naiven Vorstellung nach Programmierung auf eine Schnittstelle
und nach Polymorphie, wo ich nicht Bescheid weiß.

Ich könnte mir vorstellen, daß ich irgend etwas abstraktes, was über all diesen Dingen steht, erzeugen muß.

/////////////////////////////////////////////////////////

Ja, wenn mir jemand helfen kann wäre schön.

Vielen Dank und ein schönes Fest

E. B.

[hazy fantazy]

Dafür gibt es viele verschiedene Möglichkeiten. Die einfachste wäre wohl, in beiden Fällen TA (oder TB) zu benutzen, ist das nicht möglich? Wenn du sagst, die verschiedenen Instanzen sollen zusammen passen, was genau meinst du damit?

mfg h

[Omega Psi]

Hm, ich verstehe nicht so ganz genau, wo das Problem liegt... aber ich verstehe deine Modellierung auch net so ganz. Auch Pseudocode möchte anschaulich geschrieben werden.

Ich kann dir leider nicht mehr anbieten, als eine Skizzerung meines Verständnisses des Problems und eine Sammlung von Klassen anbieten, um dir meine Gedanken zu veranschaulichen.

Das Skalarfeld ist laut Definition eine Funktion, die jedem Punkt eines Raumes eine reelle Zahl (Skalar) zuordnet.

Ich schätze mal, du hast die Vektoren und willst die Skalare dynamisch generieren? Damit haben wir schon zwei Klassen, die wir modellieren können. Den Skalar kann man auch als Klasse modellieren oder als diskreten Wert einer Funktion auf den Vektoren zurückgeben. Das Ergebnis ist dasselbe, nur die Modellierung ist ein wenig anders.

So, die ersten Klassen kann man also schon modellieren:

/** Representing a scalarfield */
class ScalarField {
    /** The vectors in the scalarfield */
    var vectors:Vectors;
    /** The scalers corresponding to the vectors */
    var scalars:Scalars; // Where to get these from?
 
    /** Constructor */
    public ScalarField(vectors:Vectors) {
        this.vectors = vectors;
    }
    
    function getVectors():Vectors {
        return this.vectors;
    }
 
    /** Subtraction of another scalarfield-instance. */
    function subtractScalarField(scalarfield:ScalarField):Void {
        // Substract a scalarfield from this.
    }   
} 

/** Representing a quantum of vectors, not a vectorfield! */
class Vectors {
    /** A single vector reference */
    var vector:Vector;
    /** Saving the vectors */
    var vectors:Array;
    
    /** Constructor */
    function Vectors() {
        // Initialzing the vectors
        // and saving them in a
        // multidimensional Array
    }
    
    /** Getting a single vector */
    function getVectorAt(row:Number, column:Number):Vector {
        return this.vectors[column][row];
    }
} 

/** Representing a single Vector */
class Vector {
    /** The components of the vector */
    var xcomponent:Number;
    var ycomponent:Number;
    
    /** Constructor */
    function Vector(xcomponent:Number, ycomponent:Number) {
        this.xcomponent = xcomponent;
        this.ycomponent = ycomponent;
    }
    
    /** Getting the x component */
    function getXComponent():Number {
        return this.xcomponent;
    }
 
    /** Getting the y component */
    function getYComponent():Number {
        return this.ycomponent;
    }
} 

Das sind nur die göbsten Funktionen und Eigenschaften, die die Klassen mitbringen sollen. Nicht berücksichtigen konnte ich, woher die Skalare kommen. Auch werden Divergenz, Rotation Richtungsableitung ect nicht berücksichtigt. Wie du die im Endeffekt in dein Programm integrierst, bleibt dir überlassen.

Wenn du nun weitere spezialisierte Skalarfelder brauchst, wobei ich nciht beurteilen kann ob das der Fall ist, würde ich diese von ScalarField erben lassen:

class SpecializedScalarField extends ScalarField {} 

Wenn deine Skizzierung etwas leichter zu lesen wäre, könnte ich vielleicht auch besseren Input geben. Aber es fehlen irgendwie Informationen.

Das Ganze riecht meiner naiven Vorstellung nach Programmierung auf eine Schnittstelle und nach Polymorphie, wo ich nicht Bescheid weiß.

Ich könnte mir vorstellen, daß ich irgend etwas abstraktes, was über all diesen Dingen steht, erzeugen muß.

Das es sich im Endeffekt ja um arithmetische Operationen auf einzelnen Vectoren zusammenfassen lässt, die in anderen Klassen gekapselt sind, ist das nicht so kompliziert. Du musst nur entscheiden, wie du wo die Daten speicherst und du die Funktionalität implementierst.

Wenn ein Scalarfeld beispielsweise ein anderes Scalarfeld addieren oder subtrahieren können soll, kannst du die Funktionalität in eine extra Klasse schreiben oder sie als Funktionaliät der Klasse ScalarField [nach meinem Code] implentieren, was vernünftig ist, da ein Scalarfeld dieses offenbar an Funktionalität zu Verfügung stellen muss.