Luxophia

1
unit LUX.Data.Grid.T3;
2

3
interface //#################################################################### ■
4

5
uses System.SysUtils, System.Classes,
6
     LUX,
7
     LUX.D3,
8
     LUX.Data.Grid,
9
     LUX.Data.Grid.T2;
10

11
type //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【型】
12

13
     TArray3D<_TItem_>             = class;
14
     TCellArray3D<_TItem_>         = class;
15
     TPoinArray3D<_TItem_>         = class;
16
     TCellIterPoinArray3D<_TItem_> = class;
17

18
     //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【レコード】
19

20
     //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【クラス】
21

22
     //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TArray3D<_TItem_>
23

24
     IArray3D = interface( IArray2D )
25
     ['{2ED01C38-BB77-4958-83DE-E4F723A74774}']
26
     {protected}
27
       ///// アクセス
28
       function GetElemsZ :Integer;
29
       function GetItemsZ :Integer;
30
       procedure SetItemsZ( const ItemsZ_:Integer );
31
       function GetMargsZ :Integer;
32
       procedure SetMargsZ( const MargsZ_:Integer );
33
       function GetItemsN :Integer;
34
       //---
35
       function GetCounStepX :Integer;
36
       function GetCounStepY :Integer;
37
       function GetCounStepZ :Integer;
38
       function GetByteStepX :Integer;
39
       function GetByteStepY :Integer;
40
       function GetByteStepZ :Integer;
41
       function GetLines( const Y_,Z_:Integer ) :PByteArray;
42
       function GetLineSize :Integer;
43
     {public}
44
       ///// プロパティ
45
       property ElemsZ :Integer read GetElemsZ                ;
46
       property ItemsZ :Integer read GetItemsZ write SetItemsZ;
47
       property MargsZ :Integer read GetMargsZ write SetMargsZ;
48
       property ItemsN :Integer read GetItemsN                ;
49
       //---
50
       property CounStepX                    :Integer    read GetCounStepX;
51
       property CounStepY                    :Integer    read GetCounStepY;
52
       property CounStepZ                    :Integer    read GetCounStepZ;
53
       property ByteStepX                    :Integer    read GetByteStepX;
54
       property ByteStepY                    :Integer    read GetByteStepY;
55
       property ByteStepZ                    :Integer    read GetByteStepZ;
56
       property Lines[ const Y_,Z_:Integer ] :PByteArray read GetLines    ;
57
       property LineSize                     :Integer    read GetLineSize ;
58
     end;
59

60
     //-------------------------------------------------------------------------
61

62
     TArray3D<_TItem_> = class( TArray2D<_TItem_>, IArray3D )
63
     public type
64
       _PItem_ = TCoreArray<_TItem_>._PElem_;
65
     private
66
       ///// メソッド
67
       function ElemsI( const X_,Y_,Z_:Integer ) :Integer; inline;
68
       function ItemsI( const X_,Y_,Z_:Integer ) :Integer; inline;
69
     protected
70
       _ElemsZ :Integer;
71
       _ItemsZ :Integer;
72
       _MargsZ :Integer;
73
       ///// アクセス
74
       function GetElemsN :Integer; override;
75
       function GetElemsZ :Integer;
76
       function GetElems( const X_,Y_,Z_:Integer ) :_TItem_;
77
       procedure SetElems( const X_,Y_,Z_:Integer; const Elem_:_TItem_ );
78
       function GetElemsP( const X_,Y_,Z_:Integer ) :_PItem_;
79
       function GetItemsZ :Integer;
80
       procedure SetItemsZ( const ItemsZ_:Integer );
81
       function GetMargsZ :Integer;
82
       procedure SetMargsZ( const MargsZ_:Integer );
83
       function GetItemsN :Integer; override;
84
       function GetItems( const X_,Y_,Z_:Integer ) :_TItem_;
85
       procedure SetItems( const X_,Y_,Z_:Integer; const Item_:_TItem_ );
86
       function GetItemsP( const X_,Y_,Z_:Integer ) :_PItem_;
87
       function GetItem0P :Pointer;
88
       //---
89
       function GetCounStepX :Integer;
90
       function GetCounStepY :Integer;
91
       function GetCounStepZ :Integer;
92
       function GetByteStepX :Integer;
93
       function GetByteStepY :Integer;
94
       function GetByteStepZ :Integer;
95
       function GetLines( const Y_,Z_:Integer ) :PByteArray;
96
       function GetLineSize :Integer;
97
       ///// メソッド
98
       procedure MakeArray; override;
99
     public
100
       constructor Create; overload;
101
       constructor Create( const ItemsX_,ItemsY_,ItemsZ_:Integer ); overload;
102
       constructor Create( const ItemsX_,ItemsY_,ItemsZ_,Margs_:Integer ); reintroduce; overload;
103
       constructor Create( const ItemsX_,ItemsY_,ItemsZ_,MargsX_,MargsY_,MargsZ_:Integer ); overload; virtual;
104
       destructor Destroy; override;
105
       ///// プロパティ
106
       property ItemByte                         :Integer    read GetElemByte                 ;
107
       property ElemsZ                           :Integer    read GetElemsZ                   ;
108
       property Elems[ const X_,Y_,Z_:Integer ]  :_TItem_    read GetElems     write SetElems ;
109
       property ElemsP[ const X_,Y_,Z_:Integer ] :_PItem_    read GetElemsP                   ;
110
       property ItemsZ                           :Integer    read GetItemsZ    write SetItemsZ;
111
       property MargsZ                           :Integer    read GetMargsZ    write SetMargsZ;
112
       property ItemsN                           :Integer    read GetItemsN                   ;
113
       property Items[ const X_,Y_,Z_:Integer ]  :_TItem_    read GetItems     write SetItems ; default;
114
       property ItemsP[ const X_,Y_,Z_:Integer ] :_PItem_    read GetItemsP                   ;
115
       property Item0P                           :Pointer    read GetItem0P                   ;
116
       //---
117
       property CounStepX                        :Integer    read GetCounStepX                ;
118
       property CounStepY                        :Integer    read GetCounStepY                ;
119
       property CounStepZ                        :Integer    read GetCounStepZ                ;
120
       property ByteStepX                        :Integer    read GetByteStepX                ;
121
       property ByteStepY                        :Integer    read GetByteStepY                ;
122
       property ByteStepZ                        :Integer    read GetByteStepZ                ;
123
       property Lines[ const Y_,Z_:Integer ]     :PByteArray read GetLines                    ;
124
       property LineSize                         :Integer    read GetLineSize                 ;
125
       ///// メソッド
126
       procedure Read( const Stream_:TStream ); virtual;
127
       procedure Write( const Stream_:TStream ); virtual;
128
     end;
129

130
     //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TCellArray3D<_TItem_>
131

132
     ICellArray3D = interface( IArray3D )
133
     ['{40BD11E7-4BF9-43F3-BE98-846C78B22EFD}']
134
       ///// アクセス
135
       function GetPoinsX :Integer;
136
       procedure SetPoinsX( const PoinX_:Integer );
137
       function GetPoinsY :Integer;
138
       procedure SetPoinsY( const PoinY_:Integer );
139
       function GetPoinsZ :Integer;
140
       procedure SetPoinsZ( const PoinZ_:Integer );
141
       ///// プロパティ
142
       property CellsX :Integer read GetItemsX write SetItemsX;
143
       property CellsY :Integer read GetItemsY write SetItemsY;
144
       property CellsZ :Integer read GetItemsZ write SetItemsZ;
145
       property PoinsX :Integer read GetPoinsX write SetPoinsX;
146
       property PoinsY :Integer read GetPoinsY write SetPoinsY;
147
       property PoinsZ :Integer read GetPoinsZ write SetPoinsZ;
148
     end;
149

150
     //-------------------------------------------------------------------------
151

152
     TCellArray3D<_TItem_> = class( TArray3D<_TItem_>, ICellArray3D )
153
     private
154
     protected
155
       ///// アクセス
156
       function GetPoinsX :Integer;
157
       procedure SetPoinsX( const PoinX_:Integer );
158
       function GetPoinsY :Integer;
159
       procedure SetPoinsY( const PoinY_:Integer );
160
       function GetPoinsZ :Integer;
161
       procedure SetPoinsZ( const PoinZ_:Integer );
162
     public
163
       ///// プロパティ
164
       property Cells[ const X_,Y_,Z_:Integer ] :_TItem_ read GetItems  write SetItems ; default;
165
       property CellsX                          :Integer read GetItemsX write SetItemsX;
166
       property CellsY                          :Integer read GetItemsY write SetItemsY;
167
       property CellsZ                          :Integer read GetItemsZ write SetItemsZ;
168
       property PoinsX                          :Integer read GetPoinsX write SetPoinsX;
169
       property PoinsY                          :Integer read GetPoinsY write SetPoinsY;
170
       property PoinsZ                          :Integer read GetPoinsZ write SetPoinsZ;
171
       ///// メソッド
172
       procedure MakeEdgePerio; override;
173
       procedure MakeEdgeMirro; override;
174
     end;
175

176
     //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TPoinArray3D<_TItem_>
177

178
     IPoinArray3D = interface( IArray3D )
179
     ['{60135172-47A4-4183-8CE9-B590E8F21835}']
180
       ///// アクセス
181
       function GetCellsX :Integer;
182
       procedure SetCellsX( const CellsX_:Integer );
183
       function GetCellsY :Integer;
184
       procedure SetCellsY( const CellsY_:Integer );
185
       function GetCellsZ :Integer;
186
       procedure SetCellsZ( const CellsZ_:Integer );
187
       ///// プロパティ
188
       property PoinsX :Integer read GetItemsX write SetItemsX;
189
       property PoinsY :Integer read GetItemsY write SetItemsY;
190
       property PoinsZ :Integer read GetItemsZ write SetItemsZ;
191
       property CellsX :Integer read GetCellsX write SetCellsX;
192
       property CellsY :Integer read GetCellsY write SetCellsY;
193
       property CellsZ :Integer read GetCellsZ write SetCellsZ;
194
     end;
195

196
     //-------------------------------------------------------------------------
197

198
     TPoinArray3D<_TItem_> = class( TArray3D<_TItem_>, IPoinArray3D )
199
     private
200
     protected
201
       ///// アクセス
202
       function GetCellsX :Integer;
203
       procedure SetCellsX( const CellsX_:Integer );
204
       function GetCellsY :Integer;
205
       procedure SetCellsY( const CellsY_:Integer );
206
       function GetCellsZ :Integer;
207
       procedure SetCellsZ( const CellsZ_:Integer );
208
       function GetCellsN :Integer;
209
       ///// メソッド
210
       function NewCellIter :TCellIterPoinArray3D<_TItem_>; virtual;
211
     public
212
       constructor Create( const CellsX_,CellsY_,CellsZ_,MargsX_,MargsY_,MargsZ_:Integer ); override;
213
       destructor Destroy; override;
214
       ///// プロパティ
215
       property Poins[ const X_,Y_,Z_:Integer ] :_TItem_ read GetItems  write SetItems ; default;
216
       property PoinsX                          :Integer read GetItemsX write SetItemsX;
217
       property PoinsY                          :Integer read GetItemsY write SetItemsY;
218
       property PoinsZ                          :Integer read GetItemsZ write SetItemsZ;
219
       property PoinsN                          :Integer read GetItemsN                ;
220
       property CellsX                          :Integer read GetCellsX write SetCellsX;
221
       property CellsY                          :Integer read GetCellsY write SetCellsY;
222
       property CellsZ                          :Integer read GetCellsZ write SetCellsZ;
223
       property CellsN                          :Integer read GetCellsN                ;
224
       ///// メソッド
225
       procedure Read( const Stream_:TStream ); override;
226
       procedure Write( const Stream_:TStream ); override;
227
       procedure ForCells( const Proc_:TConstProc<TCellIterPoinArray3D<_TItem_>> );
228
       procedure ForEdgesX( const Proc_:TConstProc<TCellIterPoinArray3D<_TItem_>> );
229
       procedure ForEdgesY( const Proc_:TConstProc<TCellIterPoinArray3D<_TItem_>> );
230
       procedure ForEdgesZ( const Proc_:TConstProc<TCellIterPoinArray3D<_TItem_>> );
231
       ///// メソッド
232
       procedure MakeEdgePerio; override;
233
       procedure MakeEdgeMirro; override;
234
     end;
235

236
     //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TCellIterPoinArray3D<_TItem_>
237

238
     ICellIterPoinArray3D<_TItem_> = interface
239
     ['{F5FE2821-AAE8-4D83-9732-956556A2E7C2}']
240
     {protected}
241
       function GetPos :TInteger3D;
242
       procedure SetPos( const Pos_:TInteger3D );
243
       function GetPoins( const X_,Y_,Z_:Shortint ) :_TItem_;
244
       procedure SetPoins( const X_,Y_,Z_:Shortint; const Item_:_TItem_ );
245
       function GetGiX( const I_:Shortint ) :Integer;
246
       function GetGiY( const I_:Shortint ) :Integer;
247
       function GetGiZ( const I_:Shortint ) :Integer;
248
     {public}
249
       property Pos                              :TInteger3D read GetPos   write SetPos  ;
250
       property Poins[ const X_,Y_,Z_:Shortint ] :_TItem_    read GetPoins write SetPoins; default;
251
       property GiX[ const I_:Shortint ]         :Integer    read GetGiX;
252
       property GiY[ const I_:Shortint ]         :Integer    read GetGiY;
253
       property GiZ[ const I_:Shortint ]         :Integer    read GetGiZ;
254
       ///// メソッド
255
       procedure GoPrevX; overload;
256
       procedure GoNextX; overload;
257
       procedure GoPrevY; overload;
258
       procedure GoNextY; overload;
259
       procedure GoPrevZ; overload;
260
       procedure GoNextZ; overload;
261
       procedure GoPrevX( const N_:Integer ); overload;
262
       procedure GoNextX( const N_:Integer ); overload;
263
       procedure GoPrevY( const N_:Integer ); overload;
264
       procedure GoNextY( const N_:Integer ); overload;
265
       procedure GoPrevZ( const N_:Integer ); overload;
266
       procedure GoNextZ( const N_:Integer ); overload;
267
       function Interp( const Xd_,Yd_,Zd_:Single ) :_TItem_;
268
       function AbsoInterp( const X_,Y_,Z_:Single ) :_TItem_;
269
     end;
270

271
     //-------------------------------------------------------------------------
272

273
     TCellIterPoinArray3D<_TItem_> = class( TInterfacedObject, ICellIterPoinArray3D<_TItem_> )
274
     private
275
     protected type
276
       _PItem_ = ^_TItem_;
277
     protected
278
       _Paren :TPoinArray3D<_TItem_>;
279
       _HeadZ :array [ -1..+2 ] of _PItem_;
280
       _HeadY :array [ -1..+2, -1..+2 ] of _PItem_;
281
       _Poins :array [ -1..+2, -1..+2, -1..+2 ] of _PItem_;
282
       _GX    :array [ -1..+2 ] of Integer;
283
       _GY    :array [ -1..+2 ] of Integer;
284
       _GZ    :array [ -1..+2 ] of Integer;
285
       ///// アクセス
286
       function GetPosX :Integer;
287
       procedure SetPosX( const PosX_:Integer );
288
       function GetPosY :Integer;
289
       procedure SetPosY( const PosY_:Integer );
290
       function GetPosZ :Integer;
291
       procedure SetPosZ( const PosZ_:Integer );
292
       function GetPos :TInteger3D;
293
       procedure SetPos( const Pos_:TInteger3D );
294
       function GetPoins( const X_,Y_,Z_:Shortint ) :_TItem_;
295
       procedure SetPoins( const X_,Y_,Z_:Shortint; const Item_:_TItem_ );
296
       function GetGiX( const I_:Shortint ) :Integer;
297
       function GetGiY( const I_:Shortint ) :Integer;
298
       function GetGiZ( const I_:Shortint ) :Integer;
299
       function GetGi( const X_,Y_,Z_:Shortint ) :TInteger3D;
300
     public
301
       constructor Create( const Array_:TPoinArray3D<_TItem_> );
302
       destructor Destroy; override;
303
       ///// プロパティ
304
       property PosX                             :Integer    read GetPosX  write SetPosX ;
305
       property PosY                             :Integer    read GetPosY  write SetPosY ;
306
       property PosZ                             :Integer    read GetPosZ  write SetPosZ ;
307
       property Pos                              :TInteger3D read GetPos   write SetPos  ;
308
       property Poins[ const X_,Y_,Z_:Shortint ] :_TItem_    read GetPoins write SetPoins; default;
309
       property GiX[ const I_:Shortint ]         :Integer    read GetGiX                 ;
310
       property GiY[ const I_:Shortint ]         :Integer    read GetGiY                 ;
311
       property GiZ[ const I_:Shortint ]         :Integer    read GetGiZ                 ;
312
       property Gi[ const X_,Y_,Z_:Shortint ]    :TInteger3D read GetGi                  ;
313
       ///// メソッド
314
       procedure GoPrevX; overload;
315
       procedure GoNextX; overload;
316
       procedure GoPrevY; overload;
317
       procedure GoNextY; overload;
318
       procedure GoPrevZ; overload;
319
       procedure GoNextZ; overload;
320
       procedure GoPrevX( const N_:Integer ); overload;
321
       procedure GoNextX( const N_:Integer ); overload;
322
       procedure GoPrevY( const N_:Integer ); overload;
323
       procedure GoNextY( const N_:Integer ); overload;
324
       procedure GoPrevZ( const N_:Integer ); overload;
325
       procedure GoNextZ( const N_:Integer ); overload;
326
       function Interp( const Xd_,Yd_,Zd_:Single ) :_TItem_; virtual;
327
       function AbsoInterp( const X_,Y_,Z_:Single ) :_TItem_; virtual;
328
       procedure ForCells( const Proc_:TProc );
329
       procedure ForEdgesX( const Proc_:TProc );
330
       procedure ForEdgesY( const Proc_:TProc );
331
       procedure ForEdgesZ( const Proc_:TProc );
332
     end;
333

334
//const //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【定数】
335

336
//var //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【変数】
337

338
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【ルーチン】
339

340
implementation //############################################################### ■
341

342
uses System.Math;
343

344
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【レコード】
345

346
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【クラス】
347

348
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TArray3D<_TItem_>
349

350
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& private
351

352
/////////////////////////////////////////////////////////////////////// メソッド
353

354
function TArray3D<_TItem_>.ElemsI( const X_,Y_,Z_:Integer ) :Integer;
355
begin
356
     Result := ( Z_ * _ElemsY + Y_ ) * _ElemsX + X_;
357
end;
358

359
function TArray3D<_TItem_>.ItemsI( const X_,Y_,Z_:Integer ) :Integer;
360
begin
361
     Result := ( ( _MargsZ + Z_ ) * _ElemsY + ( _MargsY + Y_ ) ) * _ElemsX + ( _MargsX + X_ );
362
end;
363

364
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& protected
365

366
/////////////////////////////////////////////////////////////////////// アクセス
367

368
function TArray3D<_TItem_>.GetElemsN :Integer;
369
begin
370
     Result := _ElemsZ * _ElemsY * _ElemsX;
371
end;
372

373
//------------------------------------------------------------------------------
374

375
function TArray3D<_TItem_>.GetElemsZ :Integer;
376
begin
377
     Result := _ElemsZ;
378
end;
379

380
//------------------------------------------------------------------------------
381

382
function TArray3D<_TItem_>.GetElems( const X_,Y_,Z_:Integer ) :_TItem_;
383
begin
384
     Result := _Elems[ ElemsI( X_, Y_, Z_ ) ];
385
end;
386

387
procedure TArray3D<_TItem_>.SetElems( const X_,Y_,Z_:Integer; const Elem_:_TItem_ );
388
begin
389
     _Elems[ ElemsI( X_, Y_, Z_ ) ] := Elem_;
390
end;
391

392
function TArray3D<_TItem_>.GetElemsP( const X_,Y_,Z_:Integer ) :_PItem_;
393
begin
394
     Result := @_Elems[ ElemsI( X_, Y_, Z_ ) ];
395
end;
396

397
//------------------------------------------------------------------------------
398

399
function TArray3D<_TItem_>.GetItemsZ :Integer;
400
begin
401
     Result := _ItemsZ;
402
end;
403

404
procedure TArray3D<_TItem_>.SetItemsZ( const ItemsZ_:Integer );
405
begin
406
     _ItemsZ := ItemsZ_;  MakeArray;
407
end;
408

409
function TArray3D<_TItem_>.GetMargsZ :Integer;
410
begin
411
     Result := _MargsZ;
412
end;
413

414
procedure TArray3D<_TItem_>.SetMargsZ( const MargsZ_:Integer );
415
begin
416
     _MargsZ := MargsZ_;  MakeArray;
417
end;
418

419
function TArray3D<_TItem_>.GetItemsN :Integer;
420
begin
421
     Result := _ItemsZ * _ItemsY * _ItemsX;
422
end;
423

424
//------------------------------------------------------------------------------
425

426
function TArray3D<_TItem_>.GetItems( const X_,Y_,Z_:Integer ) :_TItem_;
427
begin
428
     Result := _Elems[ ItemsI( X_, Y_, Z_ ) ];
429
end;
430

431
procedure TArray3D<_TItem_>.SetItems( const X_,Y_,Z_:Integer; const Item_:_TItem_ );
432
begin
433
     _Elems[ ItemsI( X_, Y_, Z_ ) ] := Item_;
434
end;
435

436
function TArray3D<_TItem_>.GetItemsP( const X_,Y_,Z_:Integer ) :_PItem_;
437
begin
438
     Result := @_Elems[ ItemsI( X_, Y_, Z_ ) ];
439
end;
440

441
function TArray3D<_TItem_>.GetItem0P :Pointer;
442
begin
443
     Result := GetItemsP( 0, 0, 0 );
444
end;
445

446
//------------------------------------------------------------------------------
447

448
function TArray3D<_TItem_>.GetCounStepX :Integer;
449
begin
450
     Result := 1;
451
end;
452

453
function TArray3D<_TItem_>.GetCounStepY :Integer;
454
begin
455
     Result := CounStepX * _ElemsX;
456
end;
457

458
function TArray3D<_TItem_>.GetCounStepZ :Integer;
459
begin
460
     Result := CounStepY * _ElemsY;
461
end;
462

463
//------------------------------------------------------------------------------
464

465
function TArray3D<_TItem_>.GetByteStepX :Integer;
466
begin
467
     Result := ItemByte * CounStepX;
468
end;
469

470
function TArray3D<_TItem_>.GetByteStepY :Integer;
471
begin
472
     Result := ItemByte * CounStepY;
473
end;
474

475
function TArray3D<_TItem_>.GetByteStepZ :Integer;
476
begin
477
     Result := ItemByte * CounStepZ;
478
end;
479

480
//------------------------------------------------------------------------------
481

482
function TArray3D<_TItem_>.GetLines( const Y_,Z_:Integer ) :PByteArray;
483
begin
484
     Result := @_Elems[ ItemsI( 0, Y_, Z_ ) ];
485
end;
486

487
function TArray3D<_TItem_>.GetLineSize :Integer;
488
begin
489
     Result := ItemByte * _ItemsX;
490
end;
491

492
/////////////////////////////////////////////////////////////////////// メソッド
493

494
procedure TArray3D<_TItem_>.MakeArray;
495
begin
496
     _ElemsZ := _MargsZ + _ItemsZ + _MargsZ;
497

498
     inherited;
499
end;
500

501
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& public
502

503
constructor TArray3D<_TItem_>.Create;
504
begin
505
     Create( 0, 0, 0 );
506
end;
507

508
constructor TArray3D<_TItem_>.Create( const ItemsX_,ItemsY_,ItemsZ_:Integer );
509
begin
510
     Create( ItemsX_, ItemsY_, ItemsZ_, 0 );
511
end;
512

513
constructor TArray3D<_TItem_>.Create( const ItemsX_,ItemsY_,ItemsZ_,Margs_:Integer );
514
begin
515
     Create( ItemsX_, ItemsY_, ItemsZ_, Margs_, Margs_, Margs_ );
516
end;
517

518
constructor TArray3D<_TItem_>.Create( const ItemsX_,ItemsY_,ItemsZ_,MargsX_,MargsY_,MargsZ_:Integer );
519
begin
520
     inherited Create( ItemsX_, ItemsY_, MargsX_, MargsY_ );
521

522
     _ItemsZ := ItemsZ_;
523
     _MargsZ := MargsZ_;
524
end;
525

526
destructor TArray3D<_TItem_>.Destroy;
527
begin
528

529
     inherited;
530
end;
531

532
/////////////////////////////////////////////////////////////////////// メソッド
533

534
procedure TArray3D<_TItem_>.Read( const Stream_:TStream );
535
begin
536
     Stream_.Read( _Elems[ 0 ], GetElemsByte );
537
end;
538

539
procedure TArray3D<_TItem_>.Write( const Stream_:TStream );
540
begin
541
     Stream_.Write( _Elems[ 0 ], GetElemsByte );
542
end;
543

544
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TCellArray3D<_TItem_>
545

546
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& private
547

548
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& protected
549

550
/////////////////////////////////////////////////////////////////////// アクセス
551

552
function TCellArray3D<_TItem_>.GetPoinsX :Integer;
553
begin
554
     Result := CellsX + 1;
555
end;
556

557
procedure TCellArray3D<_TItem_>.SetPoinsX( const PoinX_:Integer );
558
begin
559
     CellsX := PoinX_ - 1;
560
end;
561

562
function TCellArray3D<_TItem_>.GetPoinsY :Integer;
563
begin
564
     Result := CellsY + 1;
565
end;
566

567
procedure TCellArray3D<_TItem_>.SetPoinsY( const PoinY_:Integer );
568
begin
569
     CellsY := PoinY_ - 1;
570
end;
571

572
function TCellArray3D<_TItem_>.GetPoinsZ :Integer;
573
begin
574
     Result := CellsZ + 1;
575
end;
576

577
procedure TCellArray3D<_TItem_>.SetPoinsZ( const PoinZ_:Integer );
578
begin
579
     CellsY := PoinZ_ - 1;
580
end;
581

582
//------------------------------------------------------------------------------
583

584
procedure TCellArray3D<_TItem_>.MakeEdgePerio;
585
var
586
   MX, MY, MZ, NX, NY, NZ, HX, HY, HZ, X, Y, Z :Integer;
587
begin
588
     //                                     H   N
589
     //                                     |   |
590
     //    -3  -2  -1  00  +1  +2  +3  +4  +5  +6  +7  +8
591
     //  ┠─╂─╂─┣━╋━╋━╋━╋━╋━┫─╂─╂─┨
592
     //    +3  +4  +5  ・  ・  ・  ・  ・  ・  00  +1  +2
593

594
     MX := _MargsX;  NX := _ItemsX;  HX := _ItemsX-1;
595
     MY := _MargsY;  NY := _ItemsY;  HY := _ItemsY-1;
596
     MZ := _MargsZ;  NZ := _ItemsZ;  HZ := _ItemsZ-1;
597

598
     for Z := 00 to HZ do
599
     begin
600
          for Y := 00 to HY do
601
          begin
602
               for X := 00-MX to 00-01 do Items[ X, Y, Z ] := Items[ X + NX, Y, Z ];
603
               for X := HX+01 to HX+MX do Items[ X, Y, Z ] := Items[ X - NX, Y, Z ];
604
          end;
605

606
          for X := 00-MX to HX+MX do
607
          begin
608
               for Y := 00-MY to 00-01 do Items[ X, Y, Z ] := Items[ X, Y + NY, Z ];
609
               for Y := HY+01 to HY+MY do Items[ X, Y, Z ] := Items[ X, Y - NY, Z ];
610
          end;
611
     end;
612

613
     for Y := 00-MY to HY+MY do
614
     for X := 00-MX to HX+MX do
615
     begin
616
          for Z := 00-MZ to 00-01 do Items[ X, Y, Z ] := Items[ X, Y, Z + NZ ];
617
          for Z := HZ+01 to HZ+MZ do Items[ X, Y, Z ] := Items[ X, Y, Z - NZ ];
618
     end;
619
end;
620

621
procedure TCellArray3D<_TItem_>.MakeEdgeMirro;
622
var
623
   MX, MY, MZ, NX, NY, NZ, HX, HY, HZ, X, Y, Z :Integer;
624
begin
625
     //                                     H   N
626
     //                                     |   |
627
     //    -3  -2  -1  00  +1  +2  +3  +4  +5  +6  +7  +8
628
     //  ┠─╂─╂─┣━╋━╋━╋━╋━╋━┫─╂─╂─┨
629
     //    +2  +1  00  ・  ・  ・  ・  ・  ・  +5  +4  +3   }
630

631
     MX := _MargsX;  NX := _ItemsX;  HX := _ItemsX-1;
632
     MY := _MargsY;  NY := _ItemsY;  HY := _ItemsY-1;
633
     MZ := _MargsZ;  NZ := _ItemsZ;  HZ := _ItemsZ-1;
634

635
     for Z := 00 to HZ do
636
     begin
637
          for Y := 00 to HY do
638
          begin
639
               for X := 00-MX to 00-01 do Items[ X, Y, Z ] := Items[ 00 - X - 01, Y, Z ];
640
               for X := HX+01 to HX+MX do Items[ X, Y, Z ] := Items[ HX - X + NX, Y, Z ];
641
          end;
642

643
          for X := 00-MX to HX+MX do
644
          begin
645
               for Y := 00-MY to 00-01 do Items[ X, Y, Z ] := Items[ X, 00 - Y - 01, Z ];
646
               for Y := HY+01 to HY+MY do Items[ X, Y, Z ] := Items[ X, HY - Y + NY, Z ];
647
          end;
648
     end;
649

650
     for Y := 00-MY to HY+MY do
651
     for X := 00-MX to HX+MX do
652
     begin
653
          for Z := 00-MZ to 00-01 do Items[ X, Y, Z ] := Items[ X, Y, 00 - Z - 01 ];
654
          for Z := HZ+01 to HZ+MZ do Items[ X, Y, Z ] := Items[ X, Y, HZ - Z + NZ ];
655
     end;
656
end;
657

658
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& public
659

660
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TPoinArray3D<_TItem_>
661

662
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& private
663

664
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& protected
665

666
/////////////////////////////////////////////////////////////////////// アクセス
667

668
function TPoinArray3D<_TItem_>.GetCellsX :Integer;
669
begin
670
     Result := _ItemsX - 1;
671
end;
672

673
procedure TPoinArray3D<_TItem_>.SetCellsX( const CellsX_:Integer );
674
begin
675
     _ItemsX  := CellsX_ + 1;  MakeArray;
676
end;
677

678
function TPoinArray3D<_TItem_>.GetCellsY :Integer;
679
begin
680
     Result := _ItemsY - 1;
681
end;
682

683
procedure TPoinArray3D<_TItem_>.SetCellsY( const CellsY_:Integer );
684
begin
685
     _ItemsY  := CellsY_ + 1;  MakeArray;
686
end;
687

688
function TPoinArray3D<_TItem_>.GetCellsZ :Integer;
689
begin
690
     Result := _ItemsZ - 1;
691
end;
692

693
procedure TPoinArray3D<_TItem_>.SetCellsZ( const CellsZ_:Integer );
694
begin
695
     _ItemsZ  := CellsZ_ + 1;  MakeArray;
696
end;
697

698
function TPoinArray3D<_TItem_>.GetCellsN :Integer;
699
begin
700
     Result := CellsZ * CellsY * CellsX;
701
end;
702

703
/////////////////////////////////////////////////////////////////////// メソッド
704

705
function TPoinArray3D<_TItem_>.NewCellIter :TCellIterPoinArray3D<_TItem_>;
706
begin
707
     Result := TCellIterPoinArray3D<_TItem_>.Create( Self );
708
end;
709

710
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& public
711

712
constructor TPoinArray3D<_TItem_>.Create( const CellsX_,CellsY_,CellsZ_,MargsX_,MargsY_,MargsZ_:Integer );
713
begin
714
     inherited Create( CellsX_+1, CellsY_+1, CellsZ_+1,
715
                       MargsX_  , MargsY_  , MargsZ_   );
716

717
end;
718

719
destructor TPoinArray3D<_TItem_>.Destroy;
720
begin
721

722
     inherited;
723
end;
724

725
/////////////////////////////////////////////////////////////////////// メソッド
726

727
procedure TPoinArray3D<_TItem_>.Read( const Stream_:TStream );
728
var
729
   S, M :TCardinal3D;
730
begin
731
     with Stream_ do
732
     begin
733
          Read( S, SizeOf( TCardinal3D ) );
734
          Read( M, SizeOf( TCardinal3D ) );
735
     end;
736

737
     CellsX := S.X;
738
     CellsY := S.Y;
739
     CellsZ := S.Z;
740

741
     MargsX := M.X;
742
     MargsY := M.Y;
743
     MargsZ := M.Z;
744

745
     inherited;
746
end;
747

748
procedure TPoinArray3D<_TItem_>.Write( const Stream_:TStream );
749
var
750
   S, M :TCardinal3D;
751
begin
752
     with S do
753
     begin
754
          X := CellsX;
755
          Y := CellsY;
756
          Z := CellsZ;
757
     end;
758

759
     with M do
760
     begin
761
          X := MargsX;
762
          Y := MargsY;
763
          Z := MargsZ;
764
     end;
765

766
     with Stream_ do
767
     begin
768
          Write( S, SizeOf( TCardinal3D ) );
769
          Write( M, SizeOf( TCardinal3D ) );
770
     end;
771

772
     inherited;
773
end;
774

775
//------------------------------------------------------------------------------
776

777
procedure TPoinArray3D<_TItem_>.ForCells( const Proc_:TConstProc<TCellIterPoinArray3D<_TItem_>> );
778
var
779
   B :TCellIterPoinArray3D<_TItem_>;
780
begin
781
     B := NewCellIter;
782

783
     B.ForCells( procedure begin Proc_( B ); end );
784

785
     B.Free;
786
end;
787

788
procedure TPoinArray3D<_TItem_>.ForEdgesX( const Proc_:TConstProc<TCellIterPoinArray3D<_TItem_>> );
789
var
790
   E :TCellIterPoinArray3D<_TItem_>;
791
begin
792
     E := NewCellIter;
793

794
     E.ForEdgesX( procedure begin Proc_( E ); end );
795

796
     E.Free;
797
end;
798

799
procedure TPoinArray3D<_TItem_>.ForEdgesY( const Proc_:TConstProc<TCellIterPoinArray3D<_TItem_>> );
800
var
801
   E :TCellIterPoinArray3D<_TItem_>;
802
begin
803
     E := NewCellIter;
804

805
     E.ForEdgesY( procedure begin Proc_( E ); end );
806

807
     E.Free;
808
end;
809

810
procedure TPoinArray3D<_TItem_>.ForEdgesZ( const Proc_:TConstProc<TCellIterPoinArray3D<_TItem_>> );
811
var
812
   E :TCellIterPoinArray3D<_TItem_>;
813
begin
814
     E := NewCellIter;
815

816
     E.ForEdgesZ( procedure begin Proc_( E ); end );
817

818
     E.Free;
819
end;
820

821
//------------------------------------------------------------------------------
822

823
procedure TPoinArray3D<_TItem_>.MakeEdgePerio;
824
var
825
   MX, MY, MZ, HX, HY, HZ, X, Y, Z :Integer;
826
begin
827
     //                                       H
828
     //                                       |
829
     //  -3  -2  -1  00  +1  +2  +3  +4  +5  +6  +7  +8  +9
830
     //  ┠─╂─╂─┣━╋━╋━╋━╋━╋━┫─╂─╂─┨
831
     //  +3  +4  +5  ・  ・  ・  ・  ・  ・  00  +1  +2  +3
832

833
     MX := _MargsX;  HX := _ItemsX-1;
834
     MY := _MargsX;  HY := _ItemsX-1;
835
     MZ := _MargsZ;  HZ := _ItemsZ-1;
836

837
     for Z := 00 to HZ do
838
     begin
839
          for Y := 00 to HY do
840
          begin
841
               for X := 00-MX to 00-01 do Items[ X, Y, Z ] := Items[ X + HX, Y, Z ];
842
               for X := HX+00 to HX+MX do Items[ X, Y, Z ] := Items[ X - HX, Y, Z ];
843
          end;
844

845
          for X := 00-MX to HX+MX do
846
          begin
847
               for Y := 00-MY to 00-01 do Items[ X, Y, Z ] := Items[ X, Y + HY, Z ];
848
               for Y := HY+00 to HY+MY do Items[ X, Y, Z ] := Items[ X, Y - HY, Z ];
849
          end;
850
     end;
851

852
     for Y := 00-MY to HY+MY do
853
     for X := 00-MX to HX+MX do
854
     begin
855
          for Z := 00-MZ to 00-01 do Items[ X, Y, Z ] := Items[ X, Y, Z + HZ ];
856
          for Z := HZ+00 to HZ+MZ do Items[ X, Y, Z ] := Items[ X, Y, Z - HZ ];
857
     end;
858
end;
859

860
procedure TPoinArray3D<_TItem_>.MakeEdgeMirro;
861
var
862
   MX, MY, MZ, HX, HY, HZ, X, Y, Z :Integer;
863
begin
864
     //                                       H
865
     //                                       |
866
     //  -3  -2  -1  00  +1  +2  +3  +4  +5  +6  +7  +8  +9
867
     //  ┠─╂─╂─┣━╋━╋━╋━╋━╋━┫─╂─╂─┨
868
     //  +3  +2  +1  ・  ・  ・  ・  ・  ・  ・  +5  +4  +3
869

870
     MX := _MargsX;  HX := _ItemsX-1;
871
     MY := _MargsX;  HY := _ItemsX-1;
872
     MZ := _MargsZ;  HZ := _ItemsZ-1;
873

874
     for Z := 00 to HZ do
875
     begin
876
          for Y := 00 to HY do
877
          begin
878
               for X := 00-MX to 00-01 do Items[ X, Y, Z ] := Items[ -X       , Y, Z ];
879
               for X := HX+01 to HX+MX do Items[ X, Y, Z ] := Items[ -X + 2*HX, Y, Z ];
880
          end;
881

882
          for X := 00-MX to HX+MX do
883
          begin
884
               for Y := 00-MY to 00-01 do Items[ X, Y, Z ] := Items[ X, -Y       , Z ];
885
               for Y := HY+01 to HY+MY do Items[ X, Y, Z ] := Items[ X, -Y + 2*HY, Z ];
886
          end;
887
     end;
888

889
     for Y := 00-MY to HY+MY do
890
     for X := 00-MX to HX+MX do
891
     begin
892
          for Z := 00-MZ to 00-01 do Items[ X, Y, Z ] := Items[ X, Y, -Z        ];
893
          for Z := HZ+01 to HZ+MZ do Items[ X, Y, Z ] := Items[ X, Y, -Z + 2*HZ ];
894
     end;
895
end;
896

897
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TCellIterPoinArray3D<_TItem_>
898

899
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& private
900

901
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& protected
902

903
/////////////////////////////////////////////////////////////////////// アクセス
904

905
function TCellIterPoinArray3D<_TItem_>.GetPosX :Integer;
906
begin
907
     Result := _GX[ 0 ];
908
end;
909

910
procedure TCellIterPoinArray3D<_TItem_>.SetPosX( const PosX_:Integer );
911
var
912
   X, Y, Z :Integer;
913
begin
914
     for X := -1 to +2 do
915
     begin
916
          _GX[ X ] := PosX_ + X;
917

918
          for Y := -1 to +2 do
919
          begin
920
               for Z := -1 to +2 do
921
               begin
922
                    _Poins[ Z, Y, X ] := _HeadY[ Z, Y ];
923

924
                    Inc( _Poins[ Z, Y, X ], _GX[ X ] * _Paren.CounStepX );
925
               end;
926
          end;
927
     end;
928
end;
929

930
function TCellIterPoinArray3D<_TItem_>.GetPosY :Integer;
931
begin
932
     Result := _GY[ 0 ];
933
end;
934

935
procedure TCellIterPoinArray3D<_TItem_>.SetPosY( const PosY_:Integer );
936
var
937
   Y, Z :Integer;
938
begin
939
     for Y := -1 to +2 do
940
     begin
941
          _GY[ Y ] := PosY_ + Y;
942

943
          for Z := -1 to +2 do
944
          begin
945
               _HeadY[ Z, Y ] := _HeadZ[ Z ];
946

947
               Inc( _HeadY[ Z, Y ], _GY[ Y ] * _Paren.CounStepY );
948
          end;
949
     end;
950
end;
951

952
function TCellIterPoinArray3D<_TItem_>.GetPosZ :Integer;
953
begin
954
     Result := _GZ[ 0 ];
955
end;
956

957
procedure TCellIterPoinArray3D<_TItem_>.SetPosZ( const PosZ_:Integer );
958
var
959
   Z :Integer;
960
begin
961
     for Z := -1 to +2 do
962
     begin
963
          _GZ[ Z ] := PosZ_ + Z;
964

965
          _HeadZ[ Z ] := _Paren.Item0P;
966

967
          Inc( _HeadZ[ Z ], _GZ[ Z ] * _Paren.CounStepZ );
968
     end;
969
end;
970

971
//------------------------------------------------------------------------------
972

973
function TCellIterPoinArray3D<_TItem_>.GetPos :TInteger3D;
974
begin
975
     Result := TInteger3D.Create( PosX, PosY, PosZ );
976
end;
977

978
procedure TCellIterPoinArray3D<_TItem_>.SetPos( const Pos_:TInteger3D );
979
begin
980
     with Pos_ do
981
     begin
982
          PosZ := Z;
983
          PosY := Y;
984
          PosX := X;
985
     end;
986
end;
987

988
//------------------------------------------------------------------------------
989

990
function TCellIterPoinArray3D<_TItem_>.GetPoins( const X_,Y_,Z_:Shortint ) :_TItem_;
991
begin
992
     Result := _Poins[ Z_, Y_, X_ ]^;
993
end;
994

995
procedure TCellIterPoinArray3D<_TItem_>.SetPoins( const X_,Y_,Z_:Shortint; const Item_:_TItem_ );
996
begin
997
     _Poins[ Z_, Y_, X_ ]^ := Item_;
998
end;
999

1000
//------------------------------------------------------------------------------
1001

1002
function TCellIterPoinArray3D<_TItem_>.GetGiX( const I_:Shortint ) :Integer;
1003
begin
1004
     Result := _GX[ I_ ];
1005
end;
1006

1007
function TCellIterPoinArray3D<_TItem_>.GetGiY( const I_:Shortint ) :Integer;
1008
begin
1009
     Result := _GY[ I_ ];
1010
end;
1011

1012
function TCellIterPoinArray3D<_TItem_>.GetGiZ( const I_:Shortint ) :Integer;
1013
begin
1014
     Result := _GZ[ I_ ];
1015
end;
1016

1017
function TCellIterPoinArray3D<_TItem_>.GetGi( const X_,Y_,Z_:Shortint ) :TInteger3D;
1018
begin
1019
     with Result do
1020
     begin
1021
          X := GiX[ X_ ];
1022
          Y := GiY[ Y_ ];
1023
          Z := GiZ[ Z_ ];
1024
     end;
1025
end;
1026

1027
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& public
1028

1029
constructor TCellIterPoinArray3D<_TItem_>.Create( const Array_:TPoinArray3D<_TItem_> );
1030
begin
1031
     inherited Create;
1032

1033
     _Paren := Array_;
1034

1035
     Pos := TInteger3D.Create( 0, 0, 0 );
1036
end;
1037

1038
destructor TCellIterPoinArray3D<_TItem_>.Destroy;
1039
begin
1040

1041
     inherited;
1042
end;
1043

1044
/////////////////////////////////////////////////////////////////////// メソッド
1045

1046
procedure TCellIterPoinArray3D<_TItem_>.GoPrevX;
1047
var
1048
   Y, Z :Integer;
1049
begin
1050
     Move( _GX[ -1 ], _GX[ 0 ], 3 * SizeOf( Integer ) );  Dec( _GX[ -1 ] );
1051

1052
     for Z := -1 to +2 do
1053
     begin
1054
          for Y := -1 to +2 do
1055
          begin
1056
               Move( _Poins[ Z, Y, -1 ], _Poins[ Z, Y, 0 ], 3 * SizeOf( _PItem_ ) );
1057

1058
               Dec( _Poins[ Z, Y, -1 ], _Paren.CounStepX );
1059
          end;
1060
     end;
1061
end;
1062

1063
procedure TCellIterPoinArray3D<_TItem_>.GoNextX;
1064
var
1065
   Y, Z :Integer;
1066
begin
1067
     Move( _GX[ 0 ], _GX[ -1 ], 3 * SizeOf( Integer ) );  Inc( _GX[ +2 ] );
1068

1069
     for Z := -1 to +2 do
1070
     begin
1071
          for Y := -1 to +2 do
1072
          begin
1073
               Move( _Poins[ Z, Y, 0 ], _Poins[ Z, Y, -1 ], 3 * SizeOf( _PItem_ ) );
1074

1075
               Inc( _Poins[ Z, Y, +2 ], _Paren.CounStepX );
1076
          end;
1077
     end;
1078
end;
1079

1080
//------------------------------------------------------------------------------
1081

1082
procedure TCellIterPoinArray3D<_TItem_>.GoPrevY;
1083
var
1084
   Z, X :Integer;
1085
begin
1086
     Move( _GY[ -1 ], _GY[ 0 ], 3 * SizeOf( Integer ) );  Dec( _GY[ -1 ] );
1087

1088
     for Z := -1 to +2 do
1089
     begin
1090
          Move( _HeadY[ Z, -1 ], _HeadY[ Z, 0 ],  3 * SizeOf( _PItem_ ) );  Dec( _HeadY[ Z, -1 ], _Paren.CounStepY );
1091

1092
          Move( _Poins[ Z, -1 ], _Poins[ Z, 0 ], 12 * SizeOf( _PItem_ ) );
1093

1094
          for X := -1 to +2 do Dec( _Poins[ Z, -1, X ], _Paren.CounStepY );
1095
     end;
1096
end;
1097

1098
procedure TCellIterPoinArray3D<_TItem_>.GoNextY;
1099
var
1100
   Z, X :Integer;
1101
begin
1102
     Move( _GY[ 0 ], _GY[ -1 ], 3 * SizeOf( Integer ) );  Inc( _GY[ +2 ] );
1103

1104
     for Z := -1 to +2 do
1105
     begin
1106
          Move( _HeadY[ Z, 0 ], _HeadY[ Z, -1 ],  3 * SizeOf( _PItem_ ) );  Inc( _HeadY[ Z, +2 ], _Paren.CounStepY );
1107

1108
          Move( _Poins[ Z, 0 ], _Poins[ Z, -1 ], 12 * SizeOf( _PItem_ ) );
1109

1110
          for X := -1 to +2 do Inc( _Poins[ Z, +2, X ], _Paren.CounStepY );
1111
     end;
1112
end;
1113

1114
//------------------------------------------------------------------------------
1115

1116
procedure TCellIterPoinArray3D<_TItem_>.GoPrevZ;
1117
var
1118
   X, Y :Integer;
1119
begin
1120
     Move( _GZ[ -1 ], _GZ[ 0 ], 3 * SizeOf( Integer ) );  Dec( _GZ[ -1 ] );
1121

1122
     Move( _HeadZ[ -1 ], _HeadZ[ 0 ], 3 * SizeOf( _PItem_ ) );  Dec( _HeadZ[ -1 ], _Paren.CounStepZ );
1123

1124
     Move( _Poins[ -1 ], _Poins[ 0 ], 48 * SizeOf( _PItem_ ) );
1125

1126
     for Y := -1 to +2 do
1127
     begin
1128
          for X := -1 to +2 do Dec( _Poins[ -1, Y, X ], _Paren.CounStepZ );
1129
     end;
1130
end;
1131

1132
procedure TCellIterPoinArray3D<_TItem_>.GoNextZ;
1133
var
1134
   X, Y :Integer;
1135
begin
1136
     Move( _GZ[ 0 ], _GZ[ -1 ], 3 * SizeOf( Integer ) );  Inc( _GZ[ +2 ] );
1137

1138
     Move( _HeadZ[ 0 ], _HeadZ[ -1 ], 3 * SizeOf( _PItem_ ) );  Inc( _HeadZ[ +2 ], _Paren.CounStepZ );
1139

1140
     Move( _Poins[ 0 ], _Poins[ -1 ], 48 * SizeOf( _PItem_ ) );
1141

1142
     for Y := -1 to +2 do
1143
     begin
1144
          for X := -1 to +2 do
1145
          begin
1146
               Inc( _Poins[ +2, Y, X ], _Paren.CounStepZ );
1147
          end;
1148
     end;
1149
end;
1150

1151
//------------------------------------------------------------------------------
1152

1153
procedure TCellIterPoinArray3D<_TItem_>.GoPrevX( const N_:Integer );
1154
var
1155
   N :Integer;
1156
begin
1157
     for N := 1 to N_ do GoPrevX;
1158
end;
1159

1160
procedure TCellIterPoinArray3D<_TItem_>.GoNextX( const N_:Integer );
1161
var
1162
   N :Integer;
1163
begin
1164
     for N := 1 to N_ do GoNextX;
1165
end;
1166

1167
procedure TCellIterPoinArray3D<_TItem_>.GoPrevY( const N_:Integer );
1168
var
1169
   N :Integer;
1170
begin
1171
     for N := 1 to N_ do GoPrevY;
1172
end;
1173

1174
procedure TCellIterPoinArray3D<_TItem_>.GoNextY( const N_:Integer );
1175
var
1176
   N :Integer;
1177
begin
1178
     for N := 1 to N_ do GoNextY;
1179
end;
1180

1181
procedure TCellIterPoinArray3D<_TItem_>.GoPrevZ( const N_:Integer );
1182
var
1183
   N :Integer;
1184
begin
1185
     for N := 1 to N_ do GoPrevZ;
1186
end;
1187

1188
procedure TCellIterPoinArray3D<_TItem_>.GoNextZ( const N_:Integer );
1189
var
1190
   N :Integer;
1191
begin
1192
     for N := 1 to N_ do GoNextZ;
1193
end;
1194

1195
//------------------------------------------------------------------------------
1196

1197
function TCellIterPoinArray3D<_TItem_>.Interp( const Xd_,Yd_,Zd_:Single ) :_TItem_;
1198
begin
1199
     Result := Poins[ Round( Xd_ ), Round( Yd_ ), Round( Zd_ ) ];
1200
end;
1201

1202
function TCellIterPoinArray3D<_TItem_>.AbsoInterp( const X_,Y_,Z_:Single ) :_TItem_;
1203
var
1204
   Xd, Yd, Zd :Single;
1205
begin
1206
     PosZ := Floor( Z_ );  Zd := Z_ - PosZ;
1207
     PosY := Floor( Y_ );  Yd := Y_ - PosY;
1208
     PosX := Floor( X_ );  Xd := X_ - PosX;
1209

1210
     Result := Interp( Xd, Yd, Zd );
1211
end;
1212

1213
//------------------------------------------------------------------------------
1214

1215
procedure TCellIterPoinArray3D<_TItem_>.ForCells( const Proc_:TProc );
1216
var
1217
   X, Y, Z :Integer;
1218
begin
1219
     PosZ := 0;
1220
     for Z := 1 to _Paren.CellsZ do
1221
     begin
1222
          PosY := 0;
1223
          for Y := 1 to _Paren.CellsY do
1224
          begin
1225
               PosX := 0;
1226
               for X := 1 to _Paren.CellsX do
1227
               begin
1228
                    Proc_;
1229

1230
                    GoNextX;
1231
               end;
1232
               GoNextY;
1233
          end;
1234
          GoNextZ;
1235
     end;
1236
end;
1237

1238
procedure TCellIterPoinArray3D<_TItem_>.ForEdgesX( const Proc_:TProc );
1239
var
1240
   X, Y, Z :Integer;
1241
begin
1242
     PosZ := 0;
1243
     for Z := 0 to _Paren.CellsZ do
1244
     begin
1245
          PosY := 0;
1246
          for Y := 0 to _Paren.CellsY do
1247
          begin
1248
               PosX := 0;
1249
               for X := 1 to _Paren.CellsX do
1250
               begin
1251
                    Proc_;
1252

1253
                    GoNextX;
1254
               end;
1255
               GoNextY;
1256
          end;
1257
          GoNextZ;
1258
     end;
1259
end;
1260

1261
procedure TCellIterPoinArray3D<_TItem_>.ForEdgesY( const Proc_:TProc );
1262
var
1263
   X, Y, Z :Integer;
1264
begin
1265
     PosZ := 0;
1266
     for Z := 0 to _Paren.CellsZ do
1267
     begin
1268
          PosY := 0;
1269
          for Y := 1 to _Paren.CellsY do
1270
          begin
1271
               PosX := 0;
1272
               for X := 0 to _Paren.CellsX do
1273
               begin
1274
                    Proc_;
1275

1276
                    GoNextX;
1277
               end;
1278
               GoNextY;
1279
          end;
1280
          GoNextZ;
1281
     end;
1282
end;
1283

1284
procedure TCellIterPoinArray3D<_TItem_>.ForEdgesZ( const Proc_:TProc );
1285
var
1286
   X, Y, Z :Integer;
1287
begin
1288
     PosZ := 0;
1289
     for Z := 1 to _Paren.CellsZ do
1290
     begin
1291
          PosY := 0;
1292
          for Y := 0 to _Paren.CellsY do
1293
          begin
1294
               PosX := 0;
1295
               for X := 0 to _Paren.CellsX do
1296
               begin
1297
                    Proc_;
1298

1299
                    GoNextX;
1300
               end;
1301
               GoNextY;
1302
          end;
1303
          GoNextZ;
1304
     end;
1305
end;
1306

1307
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【ルーチン】
1308

1309
//############################################################################## □
1310

1311
initialization //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ 初期化
1312

1313
finalization //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ 最終化
1314

1315
end. //######################################################################### ■
1316