ein Interface für ein 2D-Skalarfeld beliebiger Größe ?

[EccoBravo]

Hallo,

meine Frage geht in Richtung "Interface".

Ich will in Komponenten und einem Projekt 2D-Skalarfelder des Types single verwenden, dessen Größe
(m x n) ich nie kenne.

Wenn ich statische Arrays verwenden wollte, würde ich diese in der erforderlichen Größe nicht allgemein formulieren können. Also muß ich mit dynamischen Arrays arbeiten.
Nun müßte ich in meinem Project und den Komponenten darauf achten, daß die Arraygröße immer richtig übergeben wird, (synchronisiert ist).

Wie kann ich die Sache mit den Arrays und der Parameterübergabe im Project und den Komponenten machen, daß dieses unempfindlich auf die Implementierung in den einzelnen Programmteilen wird, und ich nicht so aufpassen muß?

Vielen Dank

E. B.

[marabu]

Hallo,

dynamische Arrays tragen ihre Dimensionierung immer mit sich herum:

Delphi-Quellcode:

const
  MAXROWS = 400;
  MAXCOLS = 300;

type
  TSingleDynMatrix = array of array of Single;

procedure ShowDimensions(sdm: TSingleDynMatrix);
begin
  ShowMessage(Format('dimensions: %d, %d', [Length(sdm), Length(sdm[0])]));
end;

procedure TestDimensions(MaxRows, MaxCols: Word);
var
  sdm: TSingleDynMatrix;
begin
  SetLength(sdm, MaxRows, MaxCols);
  ShowDimensions(sdm);
  SetLength(sdm, 0, 0);
end;

procedure TDemoForm.ButtonClick(Sender: TObject);
begin
  TestDimensions(MAXROWS, MAXCOLS);
end;

Vielleicht hast du ja dadurch eine Sorge weniger?

Freundliche Grüße

[EccoBravo]

Hallo,
und Dank an Marabu.

Wenn ich Dich richtig verstanden habe: einfach ein array of array of single deklarieren und diesen nativ in der Parameterliste übergeben.


Frage1:
Bestimmt handelt es sich bei einem solchen Typ um einen Referentdatentyp.
Wird in der Parameterliste einer Funktion ein solches Skalarfeld kopierend übergeben oder nur synchronisierend gleichgesetzt.

Frage2:
Und wie verhält es sich mit folgendem Beispiel in Richtung Code-Unempfindlichkeit
in der Art:

Delphi-Quellcode:

A : array od array of single;
...
B : array od array of single;
...
B := COPY(A);

oder

Delphi-Quellcode:

interface
var
  A : array od array of single;

procedure XYZ(B : array od array of single);
begin
end;

implementation
   ...
   XYZ(A);
   ...

Sicherlich wird das nicht gehen, und ich muß einen interface-bildenden Typ bilden.
Damit könnte ich leben.

Frage3:
gibt es gute Komponenten zu 2D-Skalarfeldern, die auch die bilineare Transformation als Algorithmus beinhalten?
(ich bilde eine Funktion eines 10x10cm-Feldes einer 25x25-Matrix in ein 10x10cm-Feld einer 17x17-Matrix ab).

Frage4:
Wie geht das richtig, Längendimensionierung in die function übernehmen?

Delphi-Quellcode:

interface
type
  TA : array od array of single;

var
  A : TA;
  Ergebnis : single;

  function XYZ(B : TA); 
  begin
     result:=B[17,17];     // hier fehlt doch die LängenDimensionierung - wie geht das richtig?
  end;

implementation
   ...
   setLength(A,25,25);
   Ergebnis :=XYZ(A);
   ...

Vielen Dank
und einen schönen Abend

E. B.

[marabu]

Zitat:

Zitat von EccoBravo

Bestimmt handelt es sich bei einem solchen Typ um einen Referentdatentyp.

Gewiss.

Zitat:

Zitat von EccoBravo

Wird in der Parameterliste einer Funktion ein solches Skalarfeld kopierend übergeben oder nur synchronisierend gleichgesetz?

Die Übergabe erfolgt nach dem Modell Call-By-Reference, d.h. es wird keine Kopie angelegt. Es gibt auch kein Copy-On-Write, alle Änderungen an der Matrix überleben die Funktion.

Zitat:

Zitat von EccoBravo

Sicherlich wird das nicht gehen, und ich muß einen interface-bildenden Typ bilden. Damit könnte ich leben.

Du musst bei der Bereitstellung der Matrix mit einer Typvereinbarung arbeiten, insbesondere bei einer mehrdimensionalen Matrix. Ohne eigene Typvereinbarung kannst du zwar gewisse Funktionen generisch gestalten, aber das funktioniert nur bei Vektoren und nicht bei Matrizen.

Zitat:

Zitat von EccoBravo

gibt es gute Komponenten zu 2D-Skalarfeldern, die auch die bilineare Transformation als Algorithmus beinhalten?

Da fehlt mir leider der Marktüberblick.

Freundliche Grüße

[dizzy]

Zitat:

Zitat von EccoBravo

Frage3:
gibt es gute Komponenten zu 2D-Skalarfeldern, die auch die bilineare Transformation als Algorithmus beinhalten?
(ich bilde eine Funktion eines 10x10cm-Feldes einer 25x25-Matrix in ein 10x10cm-Feld einer 17x17-Matrix ab).

So wie sich das liest, suchst du nach bilinearer Interpolation. (Nur damit du dich nicht u.U. unterm falschen Begriff tot suchst :))

[EccoBravo]

Hallo,

nochmal zu der Parameterübergabe 2D-Skalarfeld:

Wir redeten bisher immer über die Anpassung von Arrays auf Instanzen-Ebene.
Aber was ich im Grunde genommen suche ist die Anpassung auf klassen-Ebene.

Dann würde auch mein Beispiel

Delphi-Quellcode:

interface
type
  TA : array od array of single;

var
  A : TA;
  Ergebnis : single;

  function XYZ(B : TA);
  begin
     result:=B[17,17];     
  end;

implementation
   ...
   setLength(A,25,25);   //diese Diensionierung müsste auf Klassenebene erfolgen
   Ergebnis :=XYZ(A);
   ...

gehen.

Gibt es da Lösungen?

Viele Grüße

E. B.

[marabu]

Hallo,

Typvereinbarung und Dimensionierung sind bei dynamischen Arrays unabhängig voneinander. Und durch eine einfache Typvereinbarung hast du auch noch lange keine Klasse. Weshalb also schreibst du von "Klassenebene"? Auch deine Beispielzeilen tragen wenig zu meiner Erhellung bei - eine function ohne Rückgabewert? Hast du konkrete Probleme oder sind die eher theoretischer Natur? Vielleicht hilft es mir und anderen, wenn du dein fachliches Problem etwas besser beschreibst - eine technische Lösung kann dann leichter gefunden werden.

Freundliche Grüße

[EccoBravo]

Hallo, entschuldigt, daß ich gefragt habe,

habe sie Typenbezeichnung im Function-Kopf einfach vergessen, kann ja mal vorkommen.
Ich möchte nochmal betonen, daß ich kein Informatiker bin, sondern nur ein Nebenbeiprogrammierer!

Mein Problem etwas klarer formuliert:
ich will mit einem Ritt den Typ
TA : array of array of single
dimensionieren, so daß diese Dimensionierung für alle abgeleiteten Instanzen von TA gilt,
eigentlich gar nicht so kompliziert, nur weiß ich nicht - wie?

Vielen Dank

E. B.

[Sidorion]

Wenn die neuen Werte nur für neue Instanzen gelten sollen, kannst Du Dir mit globalen Variablen im Implementations-Teil behelfen.
Je eine für Spalten und Zeilen. Dann machst Du an die Klasse eine Klassenmethode (class procedure DimArray(_iCols,_iRows: Integer);), die diese beiden Variablen setzt. Im Constructor der Klasse dimensionierst Du dann das Array entsprechend den Variablen.
Dabei musst Du allerdings darauf achten, dass die Variablen initialisiert werden, und zwar im Initalization-Abschnit. Der ist Standardmäßig noch nicht da, kann aber direkt vor dem 'End.' eingefügt werden. hier weist Du den beiden Variablen Standardwerte zu.
!!Wichtig!!
Dabei müssen alle Zugriffe auf diese Variablen threadsicher gemacht werden. Dies geht mit einer TCriticalSection, die Du auch als globale Variable im Implementations-Teil anlegen, im Initialization erstellen und im Finalization wieder freigeben musst. Näheres siehe OH zu TCriticalSection
!!Wichtig!!

[EccoBravo]

Hallo, vielleicht noch mal zu Marabus Bitte der genaueren Formulierung meiner Frage.

Sicherlich bringe ich hier die Begriffe Klasse und Typ durcheinander. (bin eben ein altes Greenhorn)

Ich schreibe ein Projekt, in dem ich Bilder voneinander subtrahiere und andere Dinge damit mache.

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

Delphi-Quellcode:

// 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.

Delphi-Quellcode:

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

Weiterhin 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.

Delphi-Quellcode:

//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.

Delphi-Quellcode:

//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 nicht, wie ich es eben geschrieben habe.

Das ganze riecht meiner naiven Vorstellung nach nach der Programmierung auf eine Schnittstelle und Polymorphie, wo ich einfach Hilfe brauche.

Wie Du siehst Marabu, ist dieses ein praktisches Problem, das ich wegen eines theoretischen Problems nicht lösen kann.

Wäre wirklich prima, wenn Du, bzw Ihr meiner wirren Problemformulierung folgen und mir helfen könnt. Ich bin nicht in der Lage, dieses besser zu formulieren.

Nochmals Danke für Hilfe und Verständnis, auch wenn der Weihnachtsmann nun mit einer Rute zu mir kommen wird.

E. B.