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