unit Dwg;

Classes, SysUtils, Graphics, ExtCtrls;

{ TVector }

TVector = class(TComponent)

private

FEinheitsvektor: TVector;

FX, FY: Extended;

FT: TDateTime;

function GetAbs: Extended;

function GetEinheitsvektor: TVector;

protected

procedure AssignTo(Dest: TPersistent); override;

public

property Abs: Extended read GetAbs;

property Einheitsvektor: TVector read GetEinheitsvektor;

published

property X: Extended read FX write FX;

property Y: Extended read FY write FY;

property T: TDateTime read FT write FT;

end;

{ TRectangle }

TRectangle = class(TComponent)

private

FLeftBottom, FExtent, FRightTop: TVector;

function GetExtent: TVector;

function GetLeftBottom: TVector;

function GetRightTop: TVector;

procedure SetExtent(AValue: TVector);

procedure SetLeftBottom(AValue: TVector);

procedure SetRightTop(AValue: TVector);

protected

procedure AssignTo(Dest: TPersistent); override;

published

property LeftBottom: TVector read GetLeftBottom write SetLeftBottom;

property RightTop: TVector read GetRightTop write SetRightTop;

property Extent: TVector read GetExtent write SetExtent;

end;

TDrawing = class;

{ TDrawingItem }

TDrawingItem = class(TComponent)

private

FArea: TRectangle;

FColor: TColor;

FSelected: Boolean;

FSelectedColor: TColor;

function GetArea: TRectangle; virtual;

function GetDrawing: TDrawing;

procedure SetColor(AValue: TColor); virtual;

procedure SetSelected(AValue: Boolean); virtual;

procedure SetSelectedColor(AValue: TColor); virtual;

protected

{procedure LineTo(AVector: TVector); virtual;

function GetPosition: TVector; virtual;

procedure SetPosition(AValue: TVector); virtual;

property Drawing: TDrawing read GetDrawing;

public

constructor Create(AnOwner: TComponent); override;

destructor Destroy; override;

function Contains(AVector: TVector): Boolean; virtual;

procedure Draw; virtual; abstract;

procedure Print; virtual; abstract;

property Area: TRectangle read GetArea;

property Selected: Boolean read FSelected write SetSelected;

published

property SelectedColor: TColor read FSelectedColor write SetSelectedColor;

property Color: TColor read FColor write SetColor;

property Position: TVector read GetPosition write SetPosition;

end;

{ Geradenabschnitt der alles zum Zeichnen seiner selbst enthält aber auf

{ TStraightLineSection }

TStraightLineSection = class(TDrawingItem)

private

function GetDiff: TVector;

private

FA, FB, FDiff: TVector;

function GetLength: Extended;

{function GetArea: TRectangle; override;} {kein GetArea, weil nie als TFigure.Items[i] verwendet}

property Diff: TVector read GetDiff;

public

procedure Draw; override;

procedure Print; override;

property Length: Extended read GetLength;

published

{ Begrenzungen }

property A: TVector read FA write FA;

property B: TVector read FB write FB;

end;

TFigure = class(TDrawingItem)

private

FItemList, FSelectedList: TList;

function GetItemList: TList;

function GetSelectedList: TList;

procedure SetColor(AValue: TColor); override;

procedure SetSelectedColor(AValue: TColor); override;

private

function GetItemCount: Integer;

function GetItems(i: Integer): TDrawingItem;

function GetSelectedItems(i: Integer): TDrawingItem;

function GetSelectedCount: Integer;

procedure ReadItems(Reader: TReader);

procedure SetSelected(AValue: Boolean); override;

procedure WriteItems(Writer: TWriter);

property ItemList: TList read GetItemList;

property SelectedList: TList read GetSelectedList;

protected

procedure DefineProperties(Filer: TFiler); override;

function GetArea: TRectangle; override;

public

destructor Destroy; override;

procedure Append(AnItem: TDrawingItem);

procedure Clear;

procedure Deselect(AnItem: TDrawingItem);

procedure Draw; override;

procedure Print; override;

procedure Select(AnItem: TDrawingItem);

procedure ToggleSelection(AnItem: TDrawingItem);

property ItemCount: Integer read GetItemCount;

property Items[i: Integer]: TDrawingItem read GetItems;

property SelectedItems[i: Integer]: TDrawingItem read GetSelectedItems;

property SelectedCount: Integer read GetSelectedCount;

end;

TFrameBorderIndex = (fbBottom, fbRight, fbTop, fbLeft);

{ TFrame }

TFrame = class(TFigure) {rechteckiger Rahmen mit Seiten parallel zu den

private

FBorders: array[TFrameBorderIndex] of TStraightLineSection;

FHeight: Extended;

FWidth: Extended;

function GetBorders(AnIndex: TFrameBorderIndex): TStraightLineSection;

function GetLeftBottom: TVector;

procedure SetBorders(AnIndex: TFrameBorderIndex;

AValue: TStraightLineSection);

procedure SetHeight(AValue: Extended);

procedure SetLeftBottom(AValue: TVector);

procedure SetWidth(AValue: Extended);

public

procedure Draw; override;

property Borders[AnIndex: TFrameBorderIndex]: TStraightLineSection read GetBorders write SetBorders; {Seiten des Rechtecks}

published

property Height: Extended read FHeight write SetHeight;

property Width: Extended read FWidth write SetWidth;

property LeftBottom: TVector read GetLeftBottom write SetLeftBottom;

end;

{ TTextArea }

TTextArea = class(TDrawingItem)

private

{FFont: TFont;}

FHeight: Extended;

FText: string;

FWidth: Extended;

function GetArea: TRectangle; override;

{function GetFont: TFont;}

{function GetHeight: Extended;}

function GetWidth: Extended;

{procedure SetFont(AValue: TFont);

procedure SetText(AValue: string);

{procedure SetWidth(AValue: Extended);}

protected

function GetPosition: TVector; override;

{procedure SetColor(AValue: TColor); override;}

procedure SetPosition(AValue: TVector); override;

public

{destructor Destroy; override;}

procedure Draw; override;

procedure Print; override;

published

{property Font: TFont read GetFont write SetFont;}

property Text: string read FText write SetText;

property Height: Extended read FHeight write FHeight;

property Width: Extended read GetWidth write FWidth;

end;

TDrawing = class(TFigure)

private

FPaintBox: TPaintBox;

FLeftBottom, FPosition: TVector;

FPixelsPerMillimeter: Extended;

{FYPixelsPerMillimeter: Extended;}

function GetLeftBottom: TVector;

function GetPixelsPerInch: Integer;

procedure SetLeftBottom(AValue: TVector);

procedure SetPixelsPerInch(AValue: Integer);

procedure SetPixelsPerMillimeter(AValue: Extended);

{function GetPosition: TVector;

protected

function FindBorder(A, B: TVector): TVector;

function IsInPaintRect(AVector: TVector): Boolean;

function PointToVector(AVector: TVector; APoint: TPoint): TVector;

function VectorToPoint(AVector: TVector): TPoint;

public

{procedure LineTo(AVector: TVector); override;

procedure Draw; override;

procedure Focus;

function PointToVector(AVector: TVector; X, Y: Integer): TVector;

property PaintBox: TPaintBox read FPaintBox write FPaintBox;

{property Position: TVector read GetPosition write SetPosition;}

property PixelsPerInch: Integer read GetPixelsPerInch write SetPixelsPerInch;

property PixelsPerMillimeter: Extended read FPixelsPerMillimeter write SetPixelsPerMillimeter;

{property XPixelsPerMillimeter: Extended read FXPixelsPerMillimeter write FXPixelsPerMillimeter;

published

property LeftBottom: TVector read GetLeftBottom write SetLeftBottom;

end;

{ TPolygon }

TPolygon = class(TDrawingItem)

private

FAcceleration: TVector;

FEdgeList: TList;

FVelocity: TVector;

function GetEdgeList: TList;

private

FClosed: Boolean;

FPrecision: Extended;

function GetAcceleration(i: Integer): TVector;

function GetArea: TRectangle; override;

function GetEdgeCount: Integer;

function GetEdges(i: Integer): TVector;

function GetVelocities(i: Integer): TVector;

procedure ReadEdges(Reader: TReader);

procedure WriteEdges(Writer: TWriter);

property EdgeList: TList read GetEdgeList;

protected

procedure DefineProperties(Filer: TFiler); override;

public

constructor Create(AnOwner: TComponent); override;

destructor Destroy; override;

procedure Append(x, y, t: Extended);

procedure Clear;

procedure Draw; override;

procedure Print; override;

property EdgeCount: Integer read GetEdgeCount;

property Edges[i: Integer]: TVector read GetEdges;

property Acceleration[i: Integer]: TVector read GetAcceleration;

property Velocities[i: Integer]: TVector read GetVelocities;

published

property Closed: Boolean read FClosed write FClosed;

property Precision: Extended read FPrecision write FPrecision;

end;

TTrack = class(TFigure)

public

end;

function Difference(Ref, A, B: TVector): TVector;

function Sum(Ref, A, B: TVector): TVector;

function Product(Ref, A: TVector; B: Extended): TVector;

{Nur zum Debuggen:} Dialogs,

Streaming2, Printers;

function Difference(Ref, A, B: TVector): TVector;

if Ref = nil then Ref := TVector.Create(nil);

if (A <> nil) and (B <> nil) then begin

Ref.X := A.X - B.X;

Ref.Y := A.Y - B.Y;

Ref.T := A.T - B.T;

end;

Result := Ref

end;

function Sum(Ref, A, B: TVector): TVector;

if not Assigned(Ref) then Ref := TVector.Create(nil);

Ref.X := A.X + B.X;

Ref.Y := A.Y + B.Y;

Ref.T := A.T + B.T;

Result := Ref

end;

function Product(Ref, A: TVector; B: Extended): TVector;

Ref.X := A.X * B;

Ref.Y := A.Y * B;

Result := Ref

end;

function TTextArea.GetArea: TRectangle;

Result:=inherited GetArea;

Result.Extent.Y := Height;

Result.Extent.X := Width;

end;

function TTextArea.GetWidth: Extended;

if Drawing <> nil then

if Drawing.PaintBox <> nil then begin

Drawing.PaintBox.Canvas.Font.Height := -Round(Height * Drawing.PixelsPerMillimeter);

Result := Drawing.PaintBox.Canvas.TextWidth(Text) / Drawing.PixelsPerMillimeter;

FWidth := Result;

Exit

end;

Result := 0

end;

function TTextArea.GetPosition: TVector;

Result := Area.LeftBottom

end;

procedure TTextArea.SetPosition(AValue: TVector);

Area.LeftBottom.Assign(AValue);

Area.Extent.X := Width;

Area.Extent.Y := Height

end;

procedure TTextArea.SetText(AValue: string);

if FText=AValue then Exit;

FText:=AValue;

GetWidth;

end;

procedure TTextArea.Draw;

P: TPoint;

if Drawing = nil then Exit;

if Drawing.PaintBox = nil then Exit;

P := Drawing.VectorToPoint(Position);

if Selected then Drawing.PaintBox.Canvas.Font.Color := SelectedColor

else Drawing.PaintBox.Canvas.Font.Color := Color;

Drawing.PaintBox.Canvas.Font.PixelsPerInch := Drawing.PixelsPerInch;

Drawing.PaintBox.Canvas.Font.Height := -Round(Height * Drawing.PixelsPerMillimeter);

with Drawing.PaintBox.Canvas do begin

TextOut(P.X, P.Y - TextHeight(Text), Text)

end;

end;

procedure TTextArea.Print;

P: TPoint;

P := Drawing.VectorToPoint(Position);

Printer.Canvas.Font.Color := Color;

Printer.Canvas.Font.PixelsPerInch := Drawing.PixelsPerInch;

Printer.Canvas.Font.Height := -Round(Height * Drawing.PixelsPerMillimeter);

with Printer.Canvas do

TextOut(P.X, P.Y - TextHeight(Text), Text)

end;

function TFrame.GetBorders(AnIndex: TFrameBorderIndex): TStraightLineSection;

if not Assigned(FBorders[AnIndex]) then

FBorders[AnIndex] := TStraightLineSection.Create(Self);

Result := FBorders[AnIndex];

case AnIndex of

fbBottom: begin

Result.A := LeftBottom;

Result.B := LeftBottom;

Result.B.X := Result.B.X + Width;

end;

fbRight:;

fbTop:;

fbLeft:;

end;

end;

function TFrame.GetLeftBottom: TVector;

Result := Area.LeftBottom

end;

procedure TFrame.SetBorders(AnIndex: TFrameBorderIndex;

AValue: TStraightLineSection);

end;

procedure TFrame.SetHeight(AValue: Extended);

if FHeight=AValue then Exit;

FHeight:=AValue;

end;

procedure TFrame.SetLeftBottom(AValue: TVector);

Area.LeftBottom.Assign(AValue)

end;

procedure TFrame.SetWidth(AValue: Extended);

if FWidth=AValue then Exit;

FWidth:=AValue;

end;

procedure TFrame.Draw;

inherited Draw;

end;

function TRectangle.GetExtent: TVector;

if not Assigned(FExtent) then FExtent := TVector.Create(Self);

Result := FExtent

end;

function TRectangle.GetLeftBottom: TVector;

if not Assigned(FLeftBottom) then FLeftBottom := TVector.Create(Self);

Result := FLeftBottom

end;

function TRectangle.GetRightTop: TVector;

Result := Sum(FRightTop, LeftBottom, Extent)

end;

procedure TRectangle.SetExtent(AValue: TVector);

LB: Extended;

if AValue.X >= 0 then GetExtent.X := AValue.X

else begin

LB := LeftBottom.X + AValue.X;

GetExtent.X := - AValue.X;

LeftBottom.X := LB

end;

if AValue.Y >= 0 then GetExtent.Y := AValue.Y

else begin

LB := LeftBottom.Y + AValue.Y;

GetExtent.Y := -AValue.Y;

LeftBottom.Y := LB

end;

end;

procedure TRectangle.SetLeftBottom(AValue: TVector);

GetLeftBottom.Assign(AValue)

end;

procedure TRectangle.SetRightTop(AValue: TVector);

if LeftBottom.X > AValue.X then begin

LeftBottom.X := AValue.X;

Extent.X := 0

end

else Extent.X := AValue.X - LeftBottom.X;

if LeftBottom.Y > AValue.Y then begin

LeftBottom.Y := AValue.Y;

Extent.Y := 0

end

else Extent.Y := AValue.Y - LeftBottom.Y

end;

procedure TRectangle.AssignTo(Dest: TPersistent);

if Dest is TRectangle then begin

(Dest as TRectangle).LeftBottom := LeftBottom;

(Dest as TRectangle).Extent := Extent

end;

end;

function TStraightLineSection.GetDiff: TVector;

if not Assigned(FDiff) then FDiff := TVector.Create(Self);

if (A <> nil) and (B <> nil) then Result := Difference(FDiff, B, A)

else Result := FDiff

end;

function TStraightLineSection.GetLength: Extended;

Result := Diff.Abs

end;

procedure TStraightLineSection.Draw;

if Drawing <> nil then

if Drawing.PaintBox <> nil then

if Drawing.IsInPaintRect(A) and Drawing.IsInPaintRect(B) then begin

if Selected then Drawing.PaintBox.Canvas.Pen.Color := SelectedColor

else Drawing.PaintBox.Canvas.Pen.Color := Color;

with Drawing do begin

PaintBox.Canvas.MoveTo(VectorToPoint(A));

PaintBox.Canvas.LineTo(VectorToPoint(B))

end;

end;

end;

procedure TStraightLineSection.Print;

if Drawing <> nil then

if Drawing.IsInPaintRect(A) and Drawing.IsInPaintRect(B) then begin

if Selected then Printer.Canvas.Pen.Color := SelectedColor

else Printer.Canvas.Pen.Color := Color;

with Drawing do begin

Printer.Canvas.MoveTo(VectorToPoint(A));

Printer.Canvas.LineTo(VectorToPoint(B))

end;

end;

end;

function TVector.GetAbs: Extended;

Result := Sqrt(Sqr(X) + Sqr(Y))

end;

function TVector.GetEinheitsvektor: TVector;

if not Assigned(FEinheitsvektor) then FEinheitsvektor := TVector.Create(Self);

FEinheitsvektor.X := X / Abs;

FEinheitsvektor.Y := Y / Abs;

Result := FEinheitsvektor

end;

procedure TVector.AssignTo(Dest: TPersistent);

D: TVector absolute Dest;

if Dest is TVector then begin

D.X := X;

D.Y := Y;

end

else inherited AssignTo(Dest)

end;

function TDrawing.GetLeftBottom: TVector;

if not Assigned(FLeftBottom) then FLeftBottom := TVector.Create(Self);

Result := FLeftBottom

end;

function TDrawing.GetPixelsPerInch: Integer;

Result := Round(PixelsPerMillimeter * 25.4)

end;

procedure TDrawing.SetLeftBottom(AValue: TVector);

GetLeftBottom.Assign(AValue)

end;

procedure TDrawing.SetPixelsPerInch(AValue: Integer);

PixelsPerMillimeter := AValue / 25.4

end;

procedure TDrawing.SetPixelsPerMillimeter(AValue: Extended);

if FPixelsPerMillimeter=AValue then Exit;

FPixelsPerMillimeter:=AValue;

end;

function TDrawing.FindBorder(A, B: TVector): TVector;

end;

function TDrawing.IsInPaintRect(AVector: TVector): Boolean;

P: TPoint;

if PaintBox <> nil then begin

P := VectorToPoint(AVector);

Result := (P.X >= 0) and (P.X < PaintBox.Width) and (P.Y >= 0) and (P.Y < PaintBox.Height)

end

else Result := False;

end;

function TDrawing.PointToVector(AVector: TVector; APoint: TPoint): TVector;

x, y: Integer;

if PaintBox <> nil then begin

if AVector = nil then AVector := TVector.Create(nil);

AVector.X := LeftBottom.X + APoint.X / PixelsPerMillimeter;

AVector.Y := LeftBottom.Y + (PaintBox.Height - APoint.Y) / PixelsPerMillimeter

end;

Result := AVector

end;

function TDrawing.PointToVector(AVector: TVector; X, Y: Integer): TVector;

Result := PointToVector(AVector, Point(X, Y))

end;

function TDrawing.VectorToPoint(AVector: TVector): TPoint;

C: TVector;

if AVector = nil then Result := Point(-1, -1)

else begin

C := Difference(nil, AVector, LeftBottom);

try

Result.X := Round(C.X * PixelsPerMillimeter);

Result.Y := PaintBox.Height - Round(C.Y * PixelsPerMillimeter);

finally

C.Free

end

end;

end;

procedure TDrawing.Draw;

if PaintBox <> nil then with PaintBox.Canvas do begin

FillRect(PaintBox.ClientRect);

end;

inherited Draw;

end;

procedure TDrawingItem.SetColor(AValue: TColor);

if FColor=AValue then Exit;

FColor:=AValue;

if not Selected then Draw

end;

procedure TDrawingItem.SetSelected(AValue: Boolean);

if FSelected=AValue then Exit;

FSelected:=AValue;

Draw

end;

procedure TDrawingItem.SetSelectedColor(AValue: TColor);

if FSelectedColor=AValue then Exit;

FSelectedColor:=AValue;

if Selected then Draw

end;

function TDrawingItem.GetPosition: TVector;

Result := Area.LeftBottom;

end;

procedure TDrawingItem.SetPosition(AValue: TVector);

Area.LeftBottom.Assign(AValue);

end;

constructor TDrawingItem.Create(AnOwner: TComponent);

inherited Create(AnOwner);

if AnOwner is TFigure then begin

TFigure(AnOwner).Append(Self);

Color := TFigure(AnOwner).Color;

SelectedColor := TFigure(AnOwner).SelectedColor;

if TFigure(Owner).Selected then TFigure(Owner).Select(Self)

end;

end;

destructor TDrawingItem.Destroy;

x: Integer;

Fig: TFigure;

if Owner <> nil then

if Owner is TFigure then begin

TComponent(Fig) := Owner;

if Fig.ItemCount > 0 then begin

x := Fig.ItemList.IndexOf(Self);

if x >= 0 then Fig.ItemList.Delete(x);

end

end;

inherited Destroy

end;

function TDrawingItem.Contains(AVector: TVector): Boolean;

Result := (AVector.X >= Area.LeftBottom.X) and (AVector.X <= Area.RightTop.X)

and (AVector.Y >= Area.LeftBottom.Y) and (AVector.Y <= Area.RightTop.Y)

end;

procedure TDrawing.Focus;

x, y: Extended;

if PaintBox <> nil then begin

LeftBottom := Area.LeftBottom;

if Area.Extent.X > 0 then x := PaintBox.Width / Area.Extent.X

else x := PixelsPerMillimeter;

if Area.Extent.Y > 0 then y := PaintBox.Height / Area.Extent.Y

else y := PixelsPerMillimeter;

if y < x then x := y;

PixelsPerMillimeter := x;

Draw

end;

end;

function TDrawingItem.GetArea: TRectangle;

if not Assigned(FArea) then FArea := TRectangle.Create(Self);

Result := FArea;

end;

function TDrawingItem.GetDrawing: TDrawing;

x: TComponent;

x := Self;

while x <> nil do begin

if x is TDrawing then begin

Result := TDrawing(x);

Exit

end;

x := x.Owner

end;

Result := nil

end;

function TPolygon.GetEdgeList: TList;

if not Assigned(FEdgeList) then FEdgeList := TList.Create;

Result := FEdgeList;

end;

function TPolygon.GetArea: TRectangle;

i: Integer;

Result:=inherited GetArea;

if EdgeCount > 0 then begin

Result.LeftBottom := Edges[0];

Result.RightTop := Edges[0];

if EdgeCount > 1 then

for i := 1 to EdgeCount - 1 do begin

if Result.LeftBottom.X > Edges[i].X then Result.LeftBottom.X := Edges[i].X;

if Result.LeftBottom.Y > Edges[i].Y then Result.LeftBottom.Y := Edges[i].Y;

if Result.RightTop.X < Edges[i].X then Result.RightTop.X := Edges[i].X;

if Result.RightTop.Y < Edges[i].Y then Result.RightTop.Y := Edges[i].Y

end;

end;

end;

function TPolygon.GetAcceleration(i: Integer): TVector;

if not Assigned(FAcceleration) then FAcceleration := TVector.Create(Self);

Result := FAcceleration;

if (i > 0) and (i < EdgeCount) then begin

if Edges[i].T <> Edges[i-1].T then begin

Result.X := (Velocities[i].X - Velocities[i-1].X) / (Edges[i].T - Edges[i-1].T);

Result.Y := (Velocities[i].Y - Velocities[i-1].Y) / (Edges[i].T - Edges[i-1].T);

end

else Result := Acceleration[i-1]

end

else begin

Result.X := 0;

Result.Y := 0

end;

end;

function TPolygon.GetEdgeCount: Integer;

if not Assigned(FEdgeList) then Result := 0

else Result := EdgeList.Count

end;

function TPolygon.GetEdges(i: Integer): TVector;

Result := TVector(EdgeList[i])

end;

function TPolygon.GetVelocities(i: Integer): TVector;

if not Assigned(FVelocity) then FVelocity := TVector.Create(Self);

Result := FVelocity;

if (i > 0) and (i < EdgeCount) then

if Edges[i].T > Edges[i-1].T then begin

Result.X := (Edges[i].X - Edges[i-1].X) / (Edges[i].T - Edges[i-1].T);

Result.Y := (Edges[i].Y - Edges[i-1].Y) / (Edges[i].T - Edges[i-1].T);

end

else Result := Velocities[i - 1]

else begin

Result.X := 0;

Result.Y := 0

end;

end;

procedure TPolygon.ReadEdges(Reader: TReader);

i, n: Integer;

x: TVector;

n := Reader.ReadInteger;

if n > 0 then begin

Reader.ReadListBegin;

for i := 0 to n - 1 do begin

x := TVector.Create(Self);

EdgeList.Add(x);

Reader.ReadComponent(x)

end;

Reader.ReadListEnd;

end;

end;

procedure TPolygon.WriteEdges(Writer: TWriter);

var i: Integer;

Writer.WriteInteger(EdgeCount);

if EdgeCount > 0 then begin

Writer.WriteListBegin;

for i := 0 to EdgeCount - 1 do Writer.WriteComponent(Edges[i]);

Writer.WriteListEnd;

end;

end;

procedure TPolygon.DefineProperties(Filer: TFiler);

inherited DefineProperties(Filer);

Filer.DefineProperty('Edges', @ReadEdges, @WriteEdges, True)

end;

constructor TPolygon.Create(AnOwner: TComponent);

inherited Create(AnOwner);

FPrecision := 0.1;

end;

destructor TPolygon.Destroy;

FEdgeList.Free;

FEdgeList := nil;

inherited Destroy;

end;

procedure TPolygon.Append(x, y, t: Extended);

C, D, Edge: TVector;

Edge := TVector.Create(Self);

Edge.X := x;

Edge.Y := y;

Edge.T := t;

if EdgeCount = 0 then EdgeList.Add(Edge)

else begin

C := TVector.Create(Self);

D := TVector.Create(Self);

try

if Difference(D, Edge, Edges[EdgeCount - 1]).Abs >= Precision then begin

if EdgeCount <= 1 then EdgeList.Add(Edge)

else begin

Difference(C, Edges[EdgeCount - 2], Edges[EdgeCount - 1]);

if C.Einheitsvektor = D.Einheitsvektor then begin

Edges[EdgeCount - 1].Assign(Edge);

Edge.Free

end

else EdgeList.Add(Edge)

end

end

else

Edge.Free

finally

D.Free;

C.Free

end

end

end;

procedure TPolygon.Clear;

var i: Integer;

if EdgeCount > 0 then begin

for i := 0 to EdgeCount - 1 do Edges[i].Free;

EdgeList.Clear

end;

end;

procedure TPolygon.Draw;

i: Integer;

LS: TStraightLineSection;