\newcommand{\tab}{\hspace{2mm}}
\chapter{Overview}

This work package consists in developing a continuous multiresolution 
model for polygonal objects that includes connectivity information 
and uses basic primitives like triangle strips to reduce the 
amount of information stored and the time required for rendering. 
Our results will be specifically applied to allow the efficient 
rendering of complex outdoor scenes, including plants and trees.


The work consists of the following main tasks:
\begin{enumerate}
\item Developing a new multiresolution model with connectivity information 
for general meshes; we call this model LODStrips.

\item Developing a new multiresolution model to represent plants and 
trees; we call this model LODTrees.
\end{enumerate}

To achieve this goal we are developing two modules, one for each
multiresolution model:


{\textbullet}\tab\textbf{Module for General Meshes.}

This module contains functions that handle the levels of detail 
of objects made of polygonal meshes. With these functions, the 
user will be able to get information about the geometry and the 
current level of detail. Besides, one has the possibility of 
changing the complexity level of the model interactively. The meshes the 
module works with use triangle strips to reduce storage usage 
and to speed up realistic rendering.


This module is implemented in the \textit{Geometry::LodStripsLibrary} 
class, which inherits from the \textit{Ogre::Renderable} and 
\textit{Ogre::Movable} classes for its integration with the engine.

{\textbullet}\tab\textbf{Module for Plants and Trees.}

This module contains functions that handle the levels of detail 
of plant and tree models. These models support separate processing 
of leaves and branches. Branches, including the trunk, are handled 
by the general mesh module. Leaves are represented using their 
own specific variable multiresolution model. In order to get 
the proper foliage geometry, the user can interact with this 
module according to his necessities.


All this functionality is integrated into the \textit{Geometry::LodTreeLibrary}
 class, which has as parent the \textit{Ogre::Renderable} and 
\textit{Ogre::Movable} classes for its correct behaviour inside the engine.



These modules are accompanied by four other support modules that 
will be independent:



{\textbullet}\tab\textbf{Simplification Module.}

This module is used by both models, general mesh and the plant 
and tree models. It contains functions that take a triangle mesh 
as input and generate simplified versions of 3D objects made 
out of triangles, while preserving its appearance.


It receives a pointer to a \textit{Geometry::Mesh} object containing 
the model to be simplified. For general meshes, this input is 
a triangle mesh, while for leaf sets (foliage) is a set of leaves, 
each made of two texture-mapped triangles.


As result of the simplification process, it returns a simplification 
sequence represented by an object that contains:\\
\begin{itemize}
\item 
For general meshes: for each simplification step the module returns 
the edge to be collapsed, the two triangles begin removed, and 
the new triangles added to the representation. All the information 
of the steps is included in a \textit{Geometry::MeshSimplificationSequence} 
object.
\item For leaf sets (foliage): for each simplification step the module 
returns the collapsed leaf, the two leaves being removed, and 
the new leaf added to the representation. This information is 
included in a \textit{Geometry::TreeSimplificationSequence} object.
\end{itemize}

This module consists of the \textit{Geometry::MeshSimplifier} for general
meshes and the \textit{Geometry::TreeSimplifier} for plants and trees. The
\textit{Geometry::MeshSimplifier} is a virtual class and must be derived in a
class that implements the simplification algorithm. This is done by means of
the classes \textit{Geometry::ImageBasedSimplifier} and
\textit{Geometry::GeometryBasedSimplifier}.


{\textbullet}\tab\textbf{Stripification (Strip Search) Module.}


This module implements methods that extract triangle strips from 
triangle meshes. It receives a pointer to a \textit{Geometry::Mesh} 
object containing the model to be stripified and returns the 
stripified mesh, contained in another \textit{Geometry::Mesh} object. It 
consists of the virtual class \textit{Geometry::Stripifier} and 
the class \textit{Geometry::CustomStripifier} that implements the 
stripifying algorithm.


{\textbullet}\tab\textbf{Construction module for general multiresolution models.}

This module stores general multiresolution mesh representations according to
the LODStrip format. Its functionality is supported by the \textit{LodStrips}
\textit{Constructor} class.


It takes as inputs the strips provided by the stripification module
(\textit{Geometry::Mesh} class) and the edge collapse sequence computed by the
simplification module (\textit{Geometry::MeshSimplificationSequence} class). It
returns a file containing the mesh generated according to the
\textit{Geometry::Mesh} object structure. Besides, it outputs a LodStrips file
with the multiresolution information.



{\textbullet}\tab\textbf{Construction module for tree multiresolution models.}

This module stores tree multiresolution representations using our own specific
file format. It consists of the \textit{Geometry::TreeConstructor} class.

It receives a file including the geometry information of the foliage
(\textit{Geometry::Mesh} object) and also a file describing the simplification
steps of the leaves (\textit{Geometry::TreeSimplificationSequence} object). The
output this module returns is a file describing the multiresolution tree
object. In addition, it references the file with the original set of leaves,
the one with the original geometry of the trunk and branches and the LodStrips
file obtained after the simplification of the trunk and branches mesh.


Besides, this modules structure requires the auxiliary
\textit{Geometry::Serializer}, \textit{Geometry::Serializable} and
\textit{Geometry::Mesh} classes. The \textit{Mesh} class represents the
structure that will store the information about the mesh that we will work
with. The \textit{Geometry::Serializer} and \textit{Geometry::Serializable}
classes implement a method that reads information from a file and stores it in
our mesh structure. It also provides a method to save this information to a
file.



%******************** Diagrama general de clases ************************
\begin{figure}
\includegraphics[scale=0.7]{../html/inherit__graph__0.png}\\
\includegraphics[scale=0.7]{../html/inherit__graph__1.png}\\
\includegraphics[scale=0.7]{../html/inherit__graph__2.png}\\
\includegraphics[scale=0.7]{../html/inherit__graph__3.png}\\
\includegraphics[scale=0.7]{../html/inherit__graph__4.png}\\
\includegraphics[scale=0.7]{../html/inherit__graph__5.png}\\
\includegraphics[scale=0.7]{../html/inherit__graph__6.png}\\
\includegraphics[scale=0.7]{../html/inherit__graph__7.png}\\
\includegraphics[scale=0.7]{../html/inherit__graph__8.png}\\
\caption{Workpackage general class diagram .}
\end{figure}