                         TKHLR
                         *****

   Le  toolkit  HLR  (Hidden  Lines  Removal)  propose   un algorithme
d'élimination des parties cachées au trait, donnant des résultats qui,
une  fois projetés,  permettent    la  réalisation de plans   avec  la
précision requise pour le dessin industriel.

   Cet  algorithme   cache des lignes  par  des  surfaces,  et non des
surfaces par des  surfaces. On ne peut donc  pas faire  directement de
l'ombrage avec    un  tel algorithme   car,  pour cela,   il  faudrait
reconstruire les morceaux de surfaces vues et cachées.

   HLR  n'inclut  pas d'algorithme de  lissage.  Un polyèdre sera donc
traité comme  tel et l'algorithme   donnera dans ce cas  des résultats
sous     forme  de segments  de     droites  conformes à la définition
polyèdrique.

   Actuellement  HLR peut traiter  des objets hétérogènes ne contenant
pas  de point ni d'objet non  fini (assemblages  de volumes, surfaces,
lignes).

   HLR traite les faces auto-intersectantes en projection mais n'admet
pas d'auto-intersection dans l'espace.

   Les résultats de HLR  sont conservés dans  sa structure  de données
afin de permettre, par exemple,  la réalisation  d'un repèrage 3D,  en
liaison avec l'objet de départ.

   HLR suppose  qu'on lui   fournit des  faces ayant  une  orientation
unique par rapport  au système de projection  (pas de ligne interne de
contour apparent).  Un tel découpage   des faces selon les lignes   de
contour apparent doit être fait au préalable ( package HLRTopoBRep ).

   Le toolkit TKHLR est composé de trois packages :

     - HLRAlgo qui rassemble tous les algorithmes et les structures de
données génériques en fonction de la géométrie et  de la topologie des
objets à visualiser et toutes les  classes propres à HLR. Pour stocker
les bornes des parties vues et cachées de chaque ligne, il utilise les
services du package  Intrv (comme gestion d'intervalles). Chaque ligne
est identifiée   comme arète   vive, ligne régulière,  isoparamétrique
et/ou contour apparent.

     -  HLRTopoBRep  qui   permet a  partir  d'un    TopoDS_Shape, des
conditions  de  projection  (HLRAlgo_Projector),  et  du nombre  d'iso
parametriques de   generer  le  TopoDS_Shape  contenant les   contours
apparents et les  isos sous forme d'Edges  non orientes dans la  face,
avec tous les partages de la structure de données topologique.

     - HLRBRep qui instancie HLRAlgo avec la géométrie et la topologie
de BRep.  L'instanciation  de l'algorithme  s'appelle HLRBRep_Algo. On
lui     ajoute   des     TopoDS_Shape   directement   ou     bien  des
HLRTopoBRep_OutLiner si l'on s'intéresse aux contours apparents et aux
isoparamétriques des faces.

   Exemples d'utilisation :

     1- avec deux TopoDS_Shape

Handle(HLRBRep_Algo) Hider = new HLRBRep_Algo();
TopoDS_Shape S1,S2;
// initialiser les TopoDS_Shape.
HLRAlgo_Projector Prj;
// initialiser le HLRAlgo_Projector
Standard_Integer nbIso = 0;
Hider->Add(S1,nbIso);
Hider->Add(S2,nbIso);
Hider->Projector(Prj);
Hider->Update();
Hider->Hide();
// retirer le TopoDS_Shape S1
Hider->Remove(Hider->Index(S1));

     2- avec un HLRTopoBRep_OutLiner

Handle(HLRBRep_Algo) Hider = new HLRBRep_Algo();
TopoDS_Shape S;
// initialiser le TopoDS_Shape.
HLRTopoBRep_OutLiner OS;
BRepAPI_MakeOutLine OutL;
HLRAlgo_Projector Prj;
// initialiser le HLRAlgo_Projector
Standard_Integer nbIso = 0;
OS.OriginalShape(S);
OS.Fill(Prj,nbIso,OutL);
TopoDS_Shape result = OS.OutLinedShape();
// ce resultat contient les IsoLines et les contours apparents.
Hider->Load(OS,nbIso);
Hider->Projector(Prj);
Hider->Update();
Hider->Hide();

   Lien entre les nouveaux Shapes et les anciens.

TopoDS_Shape Sh,SOld,SNew;
Standard_Integer index = Hider[1]->Index(Sh);
TopoDS_Shape SOld = Hider[1]->ShapeBounds(index).Shape()
    ->DataStructure().NewSOldS(SNew);

   Lecture des résultats :

     1- générale

HLRBRep_HLRToShape Tool(Hider);
TopoDS_Shape V  = Tool.VCompound       ();// arètes vives       vues
TopoDS_Shape V1 = Tool.Rg1LineVCompound();// arètes régulières  vues
TopoDS_Shape VN = Tool.RgNLineVCompound();// arètes de couture  vues
TopoDS_Shape VO = Tool.OutLineVCompound();// contours apparents vus
TopoDS_Shape VI = Tool.IsoLineVCompound();// isoparamétriques   vues
TopoDS_Shape H  = Tool.HCompound       ();// arètes vives       cachées
TopoDS_Shape H1 = Tool.Rg1LineHCompound();// arètes régulières  cachées
TopoDS_Shape HN = Tool.RgNLineHCompound();// arètes de couture  cachées
TopoDS_Shape HO = Tool.OutLineHCompound();// contours apparents cachés
TopoDS_Shape HI = Tool.IsoLineHCompound();// isoparamétriques   cachées

     2- sur tous les edges d'un TopoDS_Shape

TopoDS_Shape S;
HLRBRep_HLRToShape Tool(Hider);
TopoDS_Shape V  = Tool.VCompound       (S);// arètes vives       vues
TopoDS_Shape V1 = Tool.Rg1LineVCompound(S);// arètes régulières  vues
TopoDS_Shape VN = Tool.RgNLineVCompound(S);// arètes de couture  vues
TopoDS_Shape VO = Tool.OutLineVCompound(S);// contours apparents vus
TopoDS_Shape VI = Tool.IsoLineVCompound(S);// isoparamétriques   vues
TopoDS_Shape H  = Tool.HCompound       (S);// arètes vives       cachées
TopoDS_Shape H1 = Tool.Rg1LineHCompound(S);// arètes régulières  cachées
TopoDS_Shape HN = Tool.RgNLineHCompound(S);// arètes de couture  cachées
TopoDS_Shape HO = Tool.OutLineHCompound(S);// contours apparents cachés
TopoDS_Shape HI = Tool.IsoLineHCompound(S);// isoparamétriques   cachées


   Restrictions actuelles :

     - pas de traitement des Points.

     - pas d'utilisation de plan de clipping selon Z.

     - pas de traitement des faces ou lignes infinies.


   Un package HLRTest permet de tester cet algorithme en utilisant
les outils internes de visualisation DBRep et Draw.


