if GroupMode then begin
{$IFDEF GROUPON}
Process := 1; // ищем точки - центры внутринних стержней поверхностей
for i := 0 to Count3dsFace - 1 do
begin
Import3DModel.ProgressMain.Position := Round(i / Count3dsFace * 10);
Import3DModel.ProgressPoxel.Position := i;
if RunThread.Terminated then
Exit;
//face 1
p0a := GetXYZfPoint(i, 0);
p0b := GetXYZfPoint(i, 1);
p0c := GetXYZfPoint(i, 2);
GetSegment(p0a, p0b, p0c, p1, p2, MaxLength); // находим отрезок из
// центра треугольника по нормали внутрь с длинной Max
lastface := -1;
LenMin := MaxLength;
// Import3DModel.PoxelProcess.Caption:='Finding Div Points';
// Import3DModel.ProgressPoxel.Position:=0;
// Import3DModel.ProgressPoxel.Max:=Count3dsFace;
for k := 0 to Count3dsFace - 1 do
begin
// Import3DModel.ProgressPoxel.Position:=k;
// face 2
pa := GetXYZfPoint(k, 0);
pb := GetXYZfPoint(k, 1);
pc := GetXYZfPoint(k, 2);
// находим пересечение отрезка с треугольником
// причем минимальное!
if (k <> i) and LineFace(p1, p2, pa, pb, pc, p)
and (GetLength(p1, p) < LenMin) then
begin
p2 := p;
lastface := k;
LenMin := GetLength(p1, p2);
end;
end;
// если найден такой треугольник, то
if lastface<>-1 then
begin
// Array3DSPoints[i].Join:=-1;
Array3DSPoints[i].Active := true;
Array3DSPoints[i].p := GetDivPoint(p1, p2);
// Array3DSPoints[i].face:=i;
Array3DSPoints[i].Radius := GetLength(Array3DSPoints[i].p, p1);
//inc(IndexPoint);
end;
end;
Process := 2; // ищем радиусы от точек до ближних поверхностей
ShowRadius := 0;
Import3DModel.PoxelProcess.Caption := 'Finding Radius and Smooth Points';
Import3DModel.ProgressPoxel.Position := 0;
Import3DModel.ProgressPoxel.Max := Count3dsFace;
for i := 0 to Count3dsFace - 1 do if Array3DSPoints[i].Active then
begin
MinRadius := Array3DSPoints[i].Radius;
Import3DModel.ProgressMain.Position := 10 + Round(i / Count3dsFace * 30);
Import3DModel.ProgressPoxel.Position := i;
// теперь находим радиус точки
for r := 0 to Count3dsFace - 1 do
begin
// Import3DModel.ProgressPoxel.Position:=r;
pa := GetXYZfPoint(r, 0);
pb := GetXYZfPoint(r, 1);
pc := GetXYZfPoint(r, 2);
Radius := GetRadius(Array3DSPoints[i].p, pa, pb, pc, MinRadius, p);
if Radius < MinRadius then
MinRadius := Radius;
end;
Array3DSPoints[i].Radius := MinRadius;
ShowRadius := i;
{ end;
//итак у нас имеется массив точек, нужно уменьшить этот массив
// так чтобы у нас получились лишь конкретные точки.
// можно соединить все ближние по радиусу, уменьшим размер массива
// Radius:= LenMax*0.2;
// итак мысль вторая: сферическое сглаживание: берем точку находи ее радиус
// такой что сфера вписывается в фигуру, т.е. минимальное растояние от точки
// до плоскости
// все точки вошедшие в сферу центрируем центром масс ноходим новую сферу
// двигаем первую точку в центр, а остальные делаем не активными, оставив ссылку
// на активную точку.
Process := 3; // убераем все ближние точки входящие в радиус
Import3DModel.PoxelProcess.Caption := 'Smooth Points';
Import3DModel.ProgressPoxel.Position := 0;
Import3DModel.ProgressPoxel.Max := Count3dsFace;
for i := 0 to Count3dsFace - 1 do
begin }
found := false;
SumX := Array3DSPoints[i].p.x;
SumY := Array3DSPoints[i].p.y;
SumZ := Array3DSPoints[i].p.z;
Sum := 1;
// Import3DModel.ProgressPoxel.Position := i;
// Import3DModel.ProgressMain.Position := 30 + Round(i / Count3dsFace * 10);
// if RunThread.Terminated then
// Exit;
// Import3DModel.ProgressPoxel.Position:=0;
// Import3DModel.ProgressPoxel.Max:=IndexPoint;
if Array3DSPoints[i].Active then
for k := 0 to Count3dsFace - 1 do
begin
// Import3DModel.ProgressPoxel.Position:=k;
ShowRadius := i;
if Array3DSPoints[k].Active and (k <> i) and
(GetLength(Array3DSPoints[i].p, Array3DSPoints[k].p) < Array3DSPoints[i].Radius) then
begin
found := true;
Array3DSPoints[k].Active := false;
Array3DSPoints[k].Join := i;
SumX := SumX + Array3DSPoints[k].p.x;
SumY := SumY + Array3DSPoints[k].p.y;
SumZ := SumZ + Array3DSPoints[k].p.z;
Sum := Sum + 1;
// Radius:=GetLength(Array3DSPoints[i].p,Array3DSPoints[k].p);
end;
end;
if found then
begin
Array3DSPoints[i].p.x := SumX / Sum;
Array3DSPoints[i].p.y := SumY / Sum;
Array3DSPoints[i].p.z := SumZ / Sum;
end;
// end;
end;
// Далее создаем лучевые множества, из каждой точки к каждому элементу,
// при этом проверяем чтобы луч не пересекал треугольники
// после сканирования всех точек, подсчитываем минимальные вхождения
// затем из минимаьлных вхождений создаем множества, такие
// чтобы начало множества не входило в следующее
// получаем минимум множеств, эти минимумы и будут отсеченные элементы
Process := 4; // создаем матрицу соединений
Import3DModel.PoxelProcess.Caption := 'Joins Points';
Import3DModel.ProgressPoxel.Position := 0;
Import3DModel.ProgressPoxel.Max := Count3dsFace;
FoundMax := 1;
FoundMin := Count3dsFace;
ShowJoin := 0;
// создадим матрицу из проверочных битов размером в inxexPoint x indexPoint
SetLength(MatrixJoin, 0,0);
{ SetLength(MatrixJoin, Count3dsFace);
for i := 0 to Count3dsFace - 1 do
SetLength(MatrixJoin[i], Count3dsFace); }
SetLength(MatrixJoin,Count3dsFace,Count3dsFace);
IndexSet := 0;
for i := 0 to Count3dsFace - 1 do
begin
Import3DModel.ProgressPoxel.Position := i;
Import3DModel.ProgressMain.Position := 50 + Round(i / Count3dsFace * 35);
if RunThread.Terminated then
Exit;
FoundNum := 0;
ShowJoin := i;
if Array3DSPoints[i].Active then
for j := i + 1 to Count3dsFace - 1 do
if Array3DSPoints[j].Active and (GetLength(Array3DSPoints[i].p,
Array3DSPoints[j].p) < Array3DSPoints[i].Radius * 5) then
begin
for r := 0 to Count3dsFace - 1 do
begin
pa := GetXYZfPoint(r, 0);
pb := GetXYZfPoint(r, 1);
pc := GetXYZfPoint(r, 2);
if LineFace(Array3DSPoints[i].p, Array3DSPoints[j].p, pa,
pb, pc, p) then
Break;
end;
if r = Count3dsFace then
begin
MatrixJoin[i][j] := 1;
Array3DSPoints[j].ShowJoin := i;
Inc(FoundNum);
end;
IfMinMax(FoundMin,FoundMax,FoundNum);
{ if FoundNum > FoundMax then
FoundMax := FoundNum;
if FoundNum < FoundMin then
FoundMin := FoundNum; }
Array3DSPoints[i].Num := FoundNum;
Inc(IndexSet);
end;
end;
if IndexSet = 0 then
begin
//Process := 7;
//Exit;
IndexSet := 1
end;
SetLength(ArraySet, 0);
SetLength(ArraySet, IndexSet);
IndexSet := 0;
// Import3DModel.PoxelProcess.Caption:='Joins Points';
Import3DModel.ProgressPoxel.Position := 0;
Import3DModel.ProgressPoxel.Max := Count3dsFace;
Process := 5; // соединяем все ближние точки по матрице
for i := 0 to Count3dsFace - 1 do
if Array3DSPoints[i].Active then
begin
FoundNum := 0;
for j := i + 1 to Count3dsFace - 1 do
if MatrixJoin[i][j] = 1 then
Inc(FoundNum);
for j := 0 to i - 1 do
if MatrixJoin[j][i] = 1 then
Inc(FoundNum);
if FoundNum = 0 then
begin
//***************************************
for j := i + 1 to Count3dsFace - 1 do
if Array3DSPoints[j].Active then
begin
Import3DModel.ProgressPoxel.Position := i;
Import3DModel.ProgressMain.Position := 85 + Round(i / Count3dsFace * 5);
ShowJoin := i;
for r := 0 to Count3dsFace - 1 do
begin
pa := GetXYZfPoint(r, 0);
pb := GetXYZfPoint(r, 1);
pc := GetXYZfPoint(r, 2);
if LineFace(Array3DSPoints[i].p, Array3DSPoints[j].p, pa,
pb, pc, p) then
Break;
end;
if r = Count3dsFace then
begin
MatrixJoin[i][j] := 1;
Array3DSPoints[j].ShowJoin := i;
Inc(FoundNum);
end;
end
//***************************
end;
{ if FoundNum > FoundMax then
FoundMax := FoundNum;
if FoundNum < FoundMin then
FoundMin := FoundNum; }
IfMinMax(FoundMin,FoundMax,FoundNum);
Array3DSPoints[i].Num := FoundNum;
ArraySet[IndexSet] := i;
Inc(IndexSet);
end;
Process := 6; // сортируем массив множеств и назначаем группы
for I := 0 to IndexSet - 2 do
for J := IndexSet - 1 downto I + 1 do
if Array3DSPoints[ArraySet[I]].Num < Array3DSPoints[ArraySet[j]].Num then
begin
T := ArraySet[I];
ArraySet[I] := ArraySet[J];
ArraySet[J] := T;
end;
Import3DModel.PoxelProcess.Caption := 'Grouping';
Import3DModel.ProgressPoxel.Position := 0;
Import3DModel.ProgressPoxel.Max := IndexSet;
Group := 0;
for r := IndexSet - 1 downto 0 do
if Array3DSPoints[ArraySet[r]].Active and
(Array3DSPoints[ArraySet[r]].Group = 0) then
begin
Import3DModel.ProgressPoxel.Position := IndexSet - r;
Import3DModel.ProgressMain.Position :=
90 + Round((IndexSet - r) / Count3dsFace * 5);
i := ArraySet[r];
if (Array3DSPoints[i].Num = 0) then
begin
Inc(Group);
Array3DSPoints[i].Group := Group;
end
else //if (Array3DSPoints[ArraySet[r]].Num>10) then
begin
Inc(Group);
Array3DSPoints[i].Group := Group;
GetJoinsPoint(i, Group);
end;
end;
// увеличиваем множество, с проверкой по радиусу.
for i := 0 to Count3dsFace - 1 do
if not Array3DSPoints[i].Active then
Array3DSPoints[i].Group := Array3DSPoints[Array3DSPoints[i].Join].Group;
// теперь нам нужно из кучи множеств собрать лишь такие множества
// которые будут иметь минимальное количество элементов
// и не иметь головы множества другого множества, иначе эти
// множества можно слаживать.
// сложив минимальные множества мы получим минимум множеств
Process := 7; // группировка мелких групп
Import3DModel.PoxelProcess.Caption := 'Group Points';
Import3DModel.ProgressPoxel.Position := 0;
Import3DModel.ProgressPoxel.Max := Group;
for i := 0 to Group - 1 do
begin
Import3DModel.ProgressPoxel.Position := i;
Import3DModel.ProgressMain.Position := 95 + Round(i / Group * 5);
found := false;
SumX := 0;
SumY := 0;
SumZ := 0;
Sum := 0;
if RunThread.Terminated then
Exit;
for k := 0 to Count3dsFace - 1 do
if Array3DSPoints[k].Active and (Array3DSPoints[k].Group = i) then
begin
//(GetLength(Array3DSPoints[i].p,Array3DSPoints[k].p)<Array3DSPoints[i].Radius) then
if not found then
begin
j := k;
end
else
begin
Array3DSPoints[k].Active := false;
Array3DSPoints[k].Join := j;
end;
SumX := SumX + Array3DSPoints[k].p.x;
SumY := SumY + Array3DSPoints[k].p.y;
SumZ := SumZ + Array3DSPoints[k].p.z;
Sum := Sum + 1;
found := true;
end;
if found then
begin
Array3DSPoints[j].p.x := SumX / Sum;
Array3DSPoints[j].p.y := SumY / Sum;
Array3DSPoints[j].p.z := SumZ / Sum;
end;
end;
// найдем все группы, посчитаем их количество, присвоим num
// найдем самые маленькие num и соединим между собой пока они не
// не достингут установленного предела.
FoundMax := 1;
FoundMin := Count3dsFace;
SetLength(ArraySet, 0);
IndexSet := Group;
SetLength(ArraySet, IndexSet);
for i := 0 to Group - 1 do
begin
for k := 0 to Count3dsFace - 1 do
if Array3DSPoints[k].Active and (Array3DSPoints[k].Group = i) then
begin
j := k;
FoundNum := 1;
Break;
end;
for k := 0 to Count3dsFace - 1 do
if not Array3DSPoints[k].Active and (Array3DSPoints[k].Group = i) then
Inc(FoundNum);
IfMinMax(FoundMin,FoundMax,FoundNum);
{ if FoundNum > FoundMax then
FoundMax := FoundNum;
if FoundNum < FoundMin then
FoundMin := FoundNum; }
Array3DSPoints[j].Num := FoundNum;
ArraySet[i] := j;
end;
// Очищем матрицу соединений
{ for i := 0 to Count3dsFace - 1 do
for j := 0 to Count3dsFace - 1 do
MatrixJoin[i][j] := 0; }
SetLength(MatrixJoin, 0,0);
SetLength(MatrixJoin,Count3dsFace,Count3dsFace);
// сканируем по поверхностям, если треугольник соединяется поверхностью
// то получаем элемент. Группы соединяем поэлементно
// если треугольник группы не соединен с остальными, убираем его из группы
// таким образом мы получим замкнутые блоки
// сканирование очень простое, берем все треугольники группы, составляем матрицу
// соединений - сверяем индекс точки с индексами точек сверяемого треугольника.
// всего 9 сравнений
// находим максимальные соединения
// делим группу на элементы.
// отбрасываем минимальный элемент.
// присоединяем минимальный элемент к группе с которой он соединяется.
for i := 0 to Count3dsFace - 1 do
for j := i + 1 to Count3dsFace - 1 do
begin
if (MatrixJoin[i, j] = 0) and TestFaceConnect(i, j) then
begin
MatrixJoin[i][j] := 1;
Inc(Array3DSPoints[i].NumJoins);
Inc(Array3DSPoints[j].NumJoins);
end;
end;
// можно создать матрицу граней
// для единичной поверхности имеет три свободные грани.
// нужно отделить и соеденить с ближними.
// MatrixJoin[0][0]:=0;
// сортируем массив
{
for I := 0 to IndexSet - 2 do
for J := IndexSet-1 downto I + 1 do
if Array3DSPoints[ArraySet[I]].Num <Array3DSPoints[ArraySet[j]].Num then
begin
T := ArraySet[I];
ArraySet[I] := ArraySet[J];
ArraySet[J] := T;
end; }
///начиная с минимальных групп ведем сканирование, и соединяем их с максимальными группами
for i := 0 to 5 do
//for r:=0 to Group-1 do
//for j:=IndexSet-1 downto 0 do begin
// r - группа индекс ее
// ArraySet[r] - индекс центра группы
// бемем группу и сканируем каждый ее элемент
// отделяем элемен и присоединяем к другой группе
// r:=Array3DSPoints[ArraySet[j]].Group;
// // r:=j;
for k := 0 to Count3dsFace - 1 do
// if (Array3DSPoints[k].Group=r) then
begin
// сканируем элемент k
// находи все плоскости соединяющиеся с ним
FoundNum := GetMaxJoinsFaceGroup(k, Array3DSPoints[k].Group);
if FoundNum < 2// or (Array3DSPoints[k].NumJoins<3)
then
begin
Array3DSPoints[k].Group := FindNearGroup(k, Array3DSPoints[k].Group);
// inc(Array3DSPoints[k].NumJoins);
end;
// проверяем и считаем количество соединений с главной группой
// если соединение слабое
// соединяем с другой максимальной группой.
end;
// if Array3DSPoints[ArraySet[r]].Active
// end;
// Конец дегруппирования
IndxGroup:=1;
GroupArray:=nil;
SetLength(GroupArray,Group);
// Если есть группы
for k := 0 to Count3dsFace - 1 do
if GroupArray[Array3DSPoints[k].Group]=0 then begin
GroupArray[Array3DSPoints[k].Group]:=IndxGroup;
inc(IndxGroup);
// создаем для групп dummy poxel Name_Groups
// берем каждую группу и преобразуем в поксель
// Array3DSPoints[k].Group :=
end;
MaxVert:=Length(Obj3D.PointsArr);
SetLength(ConvertTable,MaxVert);
for g:=1 to IndxGroup-1 do
begin
PoxObj3D.Name:=Format('%s_SubGroup_%d',[Obj3D.Name,g]);
// PoxObj3D.PointsArr:=Obj3D.PointsArr;
PoxObj3D.FaceArr:=nil;
SetLength(PoxObj3D.FaceArr,Count3dsFace);
// инициализируем конверт таблицу
for i:=0 to MaxVert-1 do ConvertTable[i]:=-1;
j:=0; k:=0;
for i:=0 to Count3dsFace-1 do if (GroupArray[Array3DSPoints[i].Group]=g) then
begin // берем лицо из этой группы
// ObjArray3D[ArrayIndex].FaceArr[j]:=Obj3D.FaceArr[i];
PoxObj3D.FaceArr[j]:=Obj3D.FaceArr[i];
// копируем его в группу по индексу
for n:=0 to 2 do // заполняем таблицу конверта
if ConvertTable[Obj3D.FaceArr[i][n]]=-1 then
begin // назначаем новый номер поверхности
ConvertTable[Obj3D.FaceArr[i][n]]:=k;
PoxObj3D.FaceArr[j][n]:=k;
inc(k);
end else // назначаем назначеный номер поверхности
PoxObj3D.FaceArr[j][n]:=ConvertTable[Obj3D.FaceArr[i][n]];
inc(j);
// Import3DModel.ProgressPoxel.Position := 60+Round(i / FaceCount_3DS * 20);
end;
SetLength(PoxObj3D.FaceArr,j);
// обрезаем поверхности
SetLength(PoxObj3D.PointsArr,k);
// обрезаем точки
for i:=0 to k-1 do // копирование точек
for j:=0 to MaxVert-1 do
if ConvertTable[j]=i then
PoxObj3D.PointsArr[i]:=Obj3D.PointsArr[j];
GetPoxProperties(PoxObj3D,Poxel);
PoxObj3D.PointsArr:=nil;
PoxObj3D.FaceArr:=nil;
if RunThread.Terminated then
Exit;
end;
{$ENDIF}
end // GroupMode
Даже если убита вся команда и игра не окончена, то реинкорнировавший червь продолжает играть за команду! 
Статистика
Последние файлы
0 
Последние темы
Друзья сайта
