Yet another big style clean-up patch by Bastien Montagne, thanks a lot!
authorTamito Kajiyama <rd6t-kjym@asahi-net.or.jp>
Wed, 2 Jan 2013 01:55:30 +0000 (01:55 +0000)
committerTamito Kajiyama <rd6t-kjym@asahi-net.or.jp>
Wed, 2 Jan 2013 01:55:30 +0000 (01:55 +0000)
Now the code style is acceptable for the merge now, according to Bastien.
Thanks again Bastien for having this done! :)

58 files changed:
source/blender/freestyle/intern/view_map/ArbitraryGridDensityProvider.cpp
source/blender/freestyle/intern/view_map/ArbitraryGridDensityProvider.h
source/blender/freestyle/intern/view_map/AverageAreaGridDensityProvider.cpp
source/blender/freestyle/intern/view_map/AverageAreaGridDensityProvider.h
source/blender/freestyle/intern/view_map/BoxGrid.cpp
source/blender/freestyle/intern/view_map/BoxGrid.h
source/blender/freestyle/intern/view_map/CulledOccluderSource.cpp
source/blender/freestyle/intern/view_map/CulledOccluderSource.h
source/blender/freestyle/intern/view_map/FEdgeXDetector.cpp
source/blender/freestyle/intern/view_map/FEdgeXDetector.h
source/blender/freestyle/intern/view_map/Functions0D.cpp
source/blender/freestyle/intern/view_map/Functions0D.h
source/blender/freestyle/intern/view_map/Functions1D.cpp
source/blender/freestyle/intern/view_map/Functions1D.h
source/blender/freestyle/intern/view_map/GridDensityProvider.h
source/blender/freestyle/intern/view_map/HeuristicGridDensityProviderFactory.cpp
source/blender/freestyle/intern/view_map/HeuristicGridDensityProviderFactory.h
source/blender/freestyle/intern/view_map/Interface0D.h
source/blender/freestyle/intern/view_map/Interface1D.h
source/blender/freestyle/intern/view_map/OccluderSource.cpp
source/blender/freestyle/intern/view_map/OccluderSource.h
source/blender/freestyle/intern/view_map/Pow23GridDensityProvider.cpp
source/blender/freestyle/intern/view_map/Pow23GridDensityProvider.h
source/blender/freestyle/intern/view_map/Silhouette.cpp
source/blender/freestyle/intern/view_map/Silhouette.h
source/blender/freestyle/intern/view_map/SilhouetteGeomEngine.cpp
source/blender/freestyle/intern/view_map/SilhouetteGeomEngine.h
source/blender/freestyle/intern/view_map/SphericalGrid.cpp
source/blender/freestyle/intern/view_map/SphericalGrid.h
source/blender/freestyle/intern/view_map/SteerableViewMap.cpp
source/blender/freestyle/intern/view_map/SteerableViewMap.h
source/blender/freestyle/intern/view_map/ViewEdgeXBuilder.cpp
source/blender/freestyle/intern/view_map/ViewEdgeXBuilder.h
source/blender/freestyle/intern/view_map/ViewMap.cpp
source/blender/freestyle/intern/view_map/ViewMap.h
source/blender/freestyle/intern/view_map/ViewMapAdvancedIterators.h
source/blender/freestyle/intern/view_map/ViewMapBuilder.cpp
source/blender/freestyle/intern/view_map/ViewMapBuilder.h
source/blender/freestyle/intern/view_map/ViewMapIO.cpp
source/blender/freestyle/intern/view_map/ViewMapIO.h
source/blender/freestyle/intern/view_map/ViewMapIterators.h
source/blender/freestyle/intern/view_map/ViewMapTesselator.cpp
source/blender/freestyle/intern/view_map/ViewMapTesselator.h
source/blender/freestyle/intern/winged_edge/Curvature.cpp
source/blender/freestyle/intern/winged_edge/Curvature.h
source/blender/freestyle/intern/winged_edge/Nature.h
source/blender/freestyle/intern/winged_edge/WEdge.cpp
source/blender/freestyle/intern/winged_edge/WEdge.h
source/blender/freestyle/intern/winged_edge/WFillGrid.cpp
source/blender/freestyle/intern/winged_edge/WFillGrid.h
source/blender/freestyle/intern/winged_edge/WSFillGrid.cpp
source/blender/freestyle/intern/winged_edge/WSFillGrid.h
source/blender/freestyle/intern/winged_edge/WXEdge.cpp
source/blender/freestyle/intern/winged_edge/WXEdge.h
source/blender/freestyle/intern/winged_edge/WXEdgeBuilder.cpp
source/blender/freestyle/intern/winged_edge/WXEdgeBuilder.h
source/blender/freestyle/intern/winged_edge/WingedEdgeBuilder.cpp
source/blender/freestyle/intern/winged_edge/WingedEdgeBuilder.h

index 15b2b3343cca13472c554c9611df2f75a6f96ba6..c7925026cd5a46df7b7eda84d65b71172225e2b6 100644 (file)
@@ -1,52 +1,58 @@
-//
-//  Filename         : ArbitraryGridDensityProvider.cpp
-//  Author(s)        : Alexander Beels
-//  Purpose          : Class to define a cell grid surrounding
-//                     the projected image of a scene
-//  Date of creation : 2011-2-5
-//
-///////////////////////////////////////////////////////////////////////////////
-
-
-//
-//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
-//   with this source distribution. 
-//
-//  This program is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU General Public License
-//  as published by the Free Software Foundation; either version 2
-//  of the License, or (at your option) any later version.
-//
-//  This program is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//  GNU General Public License for more details.
-//
-//  You should have received a copy of the GNU General Public License
-//  along with this program; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
-//
-///////////////////////////////////////////////////////////////////////////////
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) 2010 Blender Foundation.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file blender/freestyle/intern/view_map/ArbitraryGridDensityProvider.cpp
+ *  \ingroup freestyle
+ *  \brief Class to define a cell grid surrounding the projected image of a scene
+ *  \author Alexander Beels
+ *  \date 2011-2-5
+ */
 
 #include "ArbitraryGridDensityProvider.h"
 
-ArbitraryGridDensityProvider::ArbitraryGridDensityProvider(OccluderSource& source, const real proscenium[4], unsigned numCells) 
-       : GridDensityProvider(source), numCells(numCells)
+ArbitraryGridDensityProvider::ArbitraryGridDensityProvider(OccluderSource& source, const real proscenium[4],
+                                                           unsigned numCells)
+: GridDensityProvider(source), numCells(numCells)
 {
        initialize (proscenium);
 }
 
-ArbitraryGridDensityProvider::ArbitraryGridDensityProvider(OccluderSource& source, const BBox<Vec3r>& bbox, const GridHelpers::Transform& transform, unsigned numCells) 
-       : GridDensityProvider(source), numCells(numCells)
+ArbitraryGridDensityProvider::ArbitraryGridDensityProvider(OccluderSource& source, const BBox<Vec3r>& bbox,
+                                                           const GridHelpers::Transform& transform, unsigned numCells)
+: GridDensityProvider(source), numCells(numCells)
 {
        real proscenium[4];
        calculateQuickProscenium(transform, bbox, proscenium);
-       
+
        initialize (proscenium);
 }
 
-ArbitraryGridDensityProvider::ArbitraryGridDensityProvider(OccluderSource& source, unsigned numCells) 
-       : GridDensityProvider(source), numCells(numCells) 
+ArbitraryGridDensityProvider::ArbitraryGridDensityProvider(OccluderSource& source, unsigned numCells)
+: GridDensityProvider(source), numCells(numCells) 
 {
        real proscenium[4];
        calculateOptimalProscenium(source, proscenium);
@@ -54,9 +60,9 @@ ArbitraryGridDensityProvider::ArbitraryGridDensityProvider(OccluderSource& sourc
        initialize (proscenium);
 }
 
-ArbitraryGridDensityProvider::~ArbitraryGridDensityProvider () {}
+ArbitraryGridDensityProvider::~ArbitraryGridDensityProvider() {}
 
-void ArbitraryGridDensityProvider::initialize (const real proscenium[4]) 
+void ArbitraryGridDensityProvider::initialize(const real proscenium[4])
 {
        float prosceniumWidth = (proscenium[1] - proscenium[0]);
        float prosceniumHeight = (proscenium[3] - proscenium[2]);
@@ -70,11 +76,11 @@ void ArbitraryGridDensityProvider::initialize (const real proscenium[4])
        cout << _cellsX << "x" << _cellsY << " cells of size " << _cellSize << " square." << endl;
 
        // Make sure the grid exceeds the proscenium by a small amount
-       float safetyZone = 0.1;
-       if ( _cellsX * _cellSize < prosceniumWidth * (1.0 + safetyZone) ) {
+       float safetyZone = 0.1f;
+       if (_cellsX * _cellSize < prosceniumWidth * (1.0 + safetyZone)) {
                _cellsX = prosceniumWidth * (1.0 + safetyZone) / _cellSize;
        }
-       if ( _cellsY * _cellSize < prosceniumHeight * (1.0 + safetyZone) ) {
+       if (_cellsY * _cellSize < prosceniumHeight * (1.0 + safetyZone)) {
                _cellsY = prosceniumHeight * (1.0 + safetyZone) / _cellSize;
        }
        cout << _cellsX << "x" << _cellsY << " cells of size " << _cellSize << " square." << endl;
@@ -85,24 +91,26 @@ void ArbitraryGridDensityProvider::initialize (const real proscenium[4])
 }
 
 ArbitraryGridDensityProviderFactory::ArbitraryGridDensityProviderFactory(unsigned numCells)
-       : numCells(numCells)
+: numCells(numCells)
 {
 }
 
-ArbitraryGridDensityProviderFactory::~ArbitraryGridDensityProviderFactory () {}
+ArbitraryGridDensityProviderFactory::~ArbitraryGridDensityProviderFactory() {}
 
-auto_ptr<GridDensityProvider> ArbitraryGridDensityProviderFactory::newGridDensityProvider(OccluderSource& source, const real proscenium[4]) 
+auto_ptr<GridDensityProvider> ArbitraryGridDensityProviderFactory::newGridDensityProvider(OccluderSource& source,
+                                                                                          const real proscenium[4])
 {
        return auto_ptr<GridDensityProvider>(new ArbitraryGridDensityProvider(source, proscenium, numCells));
 }
 
-auto_ptr<GridDensityProvider> ArbitraryGridDensityProviderFactory::newGridDensityProvider(OccluderSource& source, const BBox<Vec3r>& bbox, const GridHelpers::Transform& transform) 
+auto_ptr<GridDensityProvider>
+ArbitraryGridDensityProviderFactory::newGridDensityProvider(OccluderSource& source, const BBox<Vec3r>& bbox,
+                                                            const GridHelpers::Transform& transform)
 {
        return auto_ptr<GridDensityProvider>(new ArbitraryGridDensityProvider(source, bbox, transform, numCells));
 }
 
-auto_ptr<GridDensityProvider> ArbitraryGridDensityProviderFactory::newGridDensityProvider(OccluderSource& source) 
+auto_ptr<GridDensityProvider> ArbitraryGridDensityProviderFactory::newGridDensityProvider(OccluderSource& source)
 {
        return auto_ptr<GridDensityProvider>(new ArbitraryGridDensityProvider(source, numCells));
 }
-
index f863b2132a709692e766155d7ee9cb1b0381b131..f8d43f1993630ccc9b7f246abff9c5981c0b3f99 100644 (file)
@@ -1,48 +1,54 @@
-//
-//  Filename         : ArbitraryGridDensityProvider.h
-//  Author(s)        : Alexander Beels
-//  Purpose          : Class to define a cell grid surrounding
-//                     the projected image of a scene
-//  Date of creation : 2011-2-5
-//
-///////////////////////////////////////////////////////////////////////////////
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) 2010 Blender Foundation.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
 
+#ifndef __FREESTYLE_ARBITRARY_GRID_DENSITY_PROVIDER_H__
+#define __FREESTYLE_ARBITRARY_GRID_DENSITY_PROVIDER_H__
 
-//
-//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
-//   with this source distribution. 
-//
-//  This program is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU General Public License
-//  as published by the Free Software Foundation; either version 2
-//  of the License, or (at your option) any later version.
-//
-//  This program is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//  GNU General Public License for more details.
-//
-//  You should have received a copy of the GNU General Public License
-//  along with this program; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef ARBITRARYGRIDDENSITYPROVIDER_H
-#define ARBITRARYGRIDDENSITYPROVIDER_H
+/** \file blender/freestyle/intern/view_map/ArbitraryGridDensityProvider.h
+ *  \ingroup freestyle
+ *  \brief Class to define a cell grid surrounding the projected image of a scene
+ *  \author Alexander Beels
+ *  \date 2011-2-5
+ */
 
 #include "GridDensityProvider.h"
 
-class ArbitraryGridDensityProvider : public GridDensityProvider {
+class ArbitraryGridDensityProvider : public GridDensityProvider
+{
        // Disallow copying and assignment
-       ArbitraryGridDensityProvider (const ArbitraryGridDensityProvider& other);
-       ArbitraryGridDensityProvider& operator= (const ArbitraryGridDensityProvider& other);
+       ArbitraryGridDensityProvider(const ArbitraryGridDensityProvider& other);
+       ArbitraryGridDensityProvider& operator=(const ArbitraryGridDensityProvider& other);
 
 public:
        ArbitraryGridDensityProvider(OccluderSource& source, const real proscenium[4], unsigned numCells);
-       ArbitraryGridDensityProvider(OccluderSource& source, const BBox<Vec3r>& bbox, const GridHelpers::Transform& transform, unsigned numCells);
+       ArbitraryGridDensityProvider(OccluderSource& source, const BBox<Vec3r>& bbox,
+                                    const GridHelpers::Transform& transform, unsigned numCells);
        ArbitraryGridDensityProvider(OccluderSource& source, unsigned numCells);
-       virtual ~ArbitraryGridDensityProvider ();
+       virtual ~ArbitraryGridDensityProvider();
 
 protected:
        unsigned numCells;
@@ -51,17 +57,19 @@ private:
        void initialize (const real proscenium[4]);
 };
 
-class ArbitraryGridDensityProviderFactory : public GridDensityProviderFactory {
+class ArbitraryGridDensityProviderFactory : public GridDensityProviderFactory
+{
 public:
        ArbitraryGridDensityProviderFactory(unsigned numCells);
-       ~ArbitraryGridDensityProviderFactory ();
+       ~ArbitraryGridDensityProviderFactory();
 
        auto_ptr<GridDensityProvider> newGridDensityProvider(OccluderSource& source, const real proscenium[4]);
-       auto_ptr<GridDensityProvider> newGridDensityProvider(OccluderSource& source, const BBox<Vec3r>& bbox, const GridHelpers::Transform& transform);
+       auto_ptr<GridDensityProvider> newGridDensityProvider(OccluderSource& source, const BBox<Vec3r>& bbox,
+                                                            const GridHelpers::Transform& transform);
        auto_ptr<GridDensityProvider> newGridDensityProvider(OccluderSource& source);
+
 protected:
        unsigned numCells;
 };
 
-#endif // ARBITRARYGRIDDENSITYPROVIDER_H
-
+#endif // __FREESTYLE_ARBITRARY_GRID_DENSITY_PROVIDER_H__
index 8b4c60a7fea6d76d22022f75d3d4233ded1c8b12..4832d08f2bc6329f32f77510bccff900fe470077 100644 (file)
@@ -1,69 +1,75 @@
-//
-//  Filename         : AverageAreaGridDensityProvider.cpp
-//  Author(s)        : Alexander Beels
-//  Purpose          : Class to define a cell grid surrounding
-//                     the projected image of a scene
-//  Date of creation : 2011-2-9
-//
-///////////////////////////////////////////////////////////////////////////////
-
-
-//
-//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
-//   with this source distribution. 
-//
-//  This program is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU General Public License
-//  as published by the Free Software Foundation; either version 2
-//  of the License, or (at your option) any later version.
-//
-//  This program is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//  GNU General Public License for more details.
-//
-//  You should have received a copy of the GNU General Public License
-//  along with this program; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
-//
-///////////////////////////////////////////////////////////////////////////////
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) 2010 Blender Foundation.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file blender/freestyle/intern/view_map/AverageAreaGridDensityProvider.cpp
+ *  \ingroup freestyle
+ *  \brief Class to define a cell grid surrounding the projected image of a scene
+ *  \author Alexander Beels
+ *  \date 2011-2-9
+ */
 
 #include "AverageAreaGridDensityProvider.h"
 
-AverageAreaGridDensityProvider::AverageAreaGridDensityProvider(OccluderSource& source, const real proscenium[4], real sizeFactor) 
-       : GridDensityProvider(source)
+AverageAreaGridDensityProvider::AverageAreaGridDensityProvider(OccluderSource& source, const real proscenium[4],
+                                                               real sizeFactor)
+: GridDensityProvider(source)
 {
        initialize (proscenium, sizeFactor);
 }
 
-AverageAreaGridDensityProvider::AverageAreaGridDensityProvider(OccluderSource& source, const BBox<Vec3r>& bbox, const GridHelpers::Transform& transform, real sizeFactor) 
-       : GridDensityProvider(source)
+AverageAreaGridDensityProvider::AverageAreaGridDensityProvider(OccluderSource& source, const BBox<Vec3r>& bbox,
+                                                               const GridHelpers::Transform& transform, real sizeFactor)
+: GridDensityProvider(source)
 {
        real proscenium[4];
        calculateQuickProscenium(transform, bbox, proscenium);
-       
-       initialize (proscenium, sizeFactor);
+
+       initialize(proscenium, sizeFactor);
 }
 
-AverageAreaGridDensityProvider::AverageAreaGridDensityProvider(OccluderSource& source, real sizeFactor) 
-       : GridDensityProvider(source)
+AverageAreaGridDensityProvider::AverageAreaGridDensityProvider(OccluderSource& source, real sizeFactor)
+: GridDensityProvider(source)
 {
        real proscenium[4];
        calculateOptimalProscenium(source, proscenium);
 
-       initialize (proscenium, sizeFactor);
+       initialize(proscenium, sizeFactor);
 }
 
-AverageAreaGridDensityProvider::~AverageAreaGridDensityProvider () {}
+AverageAreaGridDensityProvider::~AverageAreaGridDensityProvider() {}
 
-void AverageAreaGridDensityProvider::initialize (const real proscenium[4], real sizeFactor) 
+void AverageAreaGridDensityProvider::initialize(const real proscenium[4], real sizeFactor)
 {
        float prosceniumWidth = (proscenium[1] - proscenium[0]);
        float prosceniumHeight = (proscenium[3] - proscenium[2]);
 
        real cellArea = 0.0;
        unsigned numFaces = 0;
-       for ( source.begin(); source.isValid(); source.next() ) {
+       for (source.begin(); source.isValid(); source.next()) {
                Polygon3r& poly(source.getGridSpacePolygon());
                Vec3r min, max;
                poly.getBBox(min, max);
@@ -82,11 +88,11 @@ void AverageAreaGridDensityProvider::initialize (const real proscenium[4], real
        cout << _cellsX << "x" << _cellsY << " cells of size " << _cellSize << " square." << endl;
 
        // Make sure the grid exceeds the proscenium by a small amount
-       float safetyZone = 0.1;
-       if ( _cellsX * _cellSize < prosceniumWidth * (1.0 + safetyZone) ) {
+       float safetyZone = 0.1f;
+       if (_cellsX * _cellSize < prosceniumWidth * (1.0 + safetyZone)) {
                _cellsX = prosceniumWidth * (1.0 + safetyZone) / _cellSize;
        }
-       if ( _cellsY * _cellSize < prosceniumHeight * (1.0 + safetyZone) ) {
+       if (_cellsY * _cellSize < prosceniumHeight * (1.0 + safetyZone)) {
                _cellsY = prosceniumHeight * (1.0 + safetyZone) / _cellSize;
        }
        cout << _cellsX << "x" << _cellsY << " cells of size " << _cellSize << " square." << endl;
@@ -97,24 +103,26 @@ void AverageAreaGridDensityProvider::initialize (const real proscenium[4], real
 }
 
 AverageAreaGridDensityProviderFactory::AverageAreaGridDensityProviderFactory(real sizeFactor)
-       : sizeFactor(sizeFactor)
+: sizeFactor(sizeFactor)
 {
 }
 
-AverageAreaGridDensityProviderFactory::~AverageAreaGridDensityProviderFactory () {}
+AverageAreaGridDensityProviderFactory::~AverageAreaGridDensityProviderFactory() {}
 
-auto_ptr<GridDensityProvider> AverageAreaGridDensityProviderFactory::newGridDensityProvider(OccluderSource& source, const real proscenium[4]) 
+auto_ptr<GridDensityProvider>
+AverageAreaGridDensityProviderFactory::newGridDensityProvider(OccluderSource& source, const real proscenium[4])
 {
        return auto_ptr<GridDensityProvider>(new AverageAreaGridDensityProvider(source, proscenium, sizeFactor));
 }
 
-auto_ptr<GridDensityProvider> AverageAreaGridDensityProviderFactory::newGridDensityProvider(OccluderSource& source, const BBox<Vec3r>& bbox, const GridHelpers::Transform& transform) 
+auto_ptr<GridDensityProvider>
+AverageAreaGridDensityProviderFactory::newGridDensityProvider(OccluderSource& source, const BBox<Vec3r>& bbox,
+                                                              const GridHelpers::Transform& transform)
 {
        return auto_ptr<GridDensityProvider>(new AverageAreaGridDensityProvider(source, bbox, transform, sizeFactor));
 }
 
-auto_ptr<GridDensityProvider> AverageAreaGridDensityProviderFactory::newGridDensityProvider(OccluderSource& source) 
+auto_ptr<GridDensityProvider> AverageAreaGridDensityProviderFactory::newGridDensityProvider(OccluderSource& source)
 {
        return auto_ptr<GridDensityProvider>(new AverageAreaGridDensityProvider(source, sizeFactor));
 }
-
index 73d28f006a78dd02495709bcbf88356a809b644d..05d2ae1ed9dcce0e35e578a84b9f29713232f255 100644 (file)
@@ -1,67 +1,72 @@
-//
-//  Filename         : AverageAreaGridDensityProvider.h
-//  Author(s)        : Alexander Beels
-//  Purpose          : Class to define a cell grid surrounding
-//                     the projected image of a scene
-//  Date of creation : 2011-2-9
-//
-///////////////////////////////////////////////////////////////////////////////
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) 2010 Blender Foundation.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
 
+#ifndef __FREESTYLE_AVERAGE_AREA_GRID_DENSITY_PROVIDER_H__
+#define __FREESTYLE_AVERAGE_AREA_GRID_DENSITY_PROVIDER_H__
 
-//
-//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
-//   with this source distribution. 
-//
-//  This program is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU General Public License
-//  as published by the Free Software Foundation; either version 2
-//  of the License, or (at your option) any later version.
-//
-//  This program is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//  GNU General Public License for more details.
-//
-//  You should have received a copy of the GNU General Public License
-//  along with this program; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef AVERAGEAREAGRIDDENSITYPROVIDER_H
-#define AVERAGEAREAGRIDDENSITYPROVIDER_H
+/** \file blender/freestyle/intern/view_map/AverageAreaGridDensityProvider.h
+ *  \ingroup freestyle
+ *  \brief Class to define a cell grid surrounding the projected image of a scene
+ *  \author Alexander Beels
+ *  \date 2011-2-9
+ */
 
 #include "GridDensityProvider.h"
 
-class AverageAreaGridDensityProvider : public GridDensityProvider {
+class AverageAreaGridDensityProvider : public GridDensityProvider
+{
        // Disallow copying and assignment
-       AverageAreaGridDensityProvider (const AverageAreaGridDensityProvider& other);
-       AverageAreaGridDensityProvider& operator= (const AverageAreaGridDensityProvider& other);
+       AverageAreaGridDensityProvider(const AverageAreaGridDensityProvider& other);
+       AverageAreaGridDensityProvider& operator=(const AverageAreaGridDensityProvider& other);
 
 public:
        AverageAreaGridDensityProvider(OccluderSource& source, const real proscenium[4], real sizeFactor);
-       AverageAreaGridDensityProvider(OccluderSource& source, const BBox<Vec3r>& bbox, const GridHelpers::Transform& transform, real sizeFactor);
+       AverageAreaGridDensityProvider(OccluderSource& source, const BBox<Vec3r>& bbox,
+                                      const GridHelpers::Transform& transform, real sizeFactor);
        AverageAreaGridDensityProvider(OccluderSource& source, real sizeFactor);
-       virtual ~AverageAreaGridDensityProvider ();
-
-protected:
+       virtual ~AverageAreaGridDensityProvider();
 
 private:
-       void initialize (const real proscenium[4], real sizeFactor); 
+       void initialize (const real proscenium[4], real sizeFactor);
 };
 
-class AverageAreaGridDensityProviderFactory : public GridDensityProviderFactory {
+class AverageAreaGridDensityProviderFactory : public GridDensityProviderFactory
+{
 public:
        AverageAreaGridDensityProviderFactory(real sizeFactor);
-       ~AverageAreaGridDensityProviderFactory ();
+       ~AverageAreaGridDensityProviderFactory();
 
        auto_ptr<GridDensityProvider> newGridDensityProvider(OccluderSource& source, const real proscenium[4]);
-       auto_ptr<GridDensityProvider> newGridDensityProvider(OccluderSource& source, const BBox<Vec3r>& bbox, const GridHelpers::Transform& transform);
+       auto_ptr<GridDensityProvider> newGridDensityProvider(OccluderSource& source, const BBox<Vec3r>& bbox,
+                                                            const GridHelpers::Transform& transform);
        auto_ptr<GridDensityProvider> newGridDensityProvider(OccluderSource& source);
 
 protected:
        real sizeFactor;
 };
 
-#endif // AVERAGEAREAGRIDDENSITYPROVIDER_H
-
+#endif // __FREESTYLE_AVERAGE_AREA_GRID_DENSITY_PROVIDER_H__
index 757cf7b655999903234c5f06ae4ab21e72d64cce..6b2804b17ce01732b0113c609062a9de1dfb19ea 100644 (file)
@@ -1,36 +1,41 @@
-//
-//  Filename         : BoxGrid.cpp
-//  Author(s)        : Alexander Beels
-//  Purpose          : Class to define a cell grid surrounding
-//                     the projected image of a scene
-//  Date of creation : 2011-1-29
-//
-///////////////////////////////////////////////////////////////////////////////
-
-//
-//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
-//   with this source distribution. 
-//
-//  This program is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU General Public License
-//  as published by the Free Software Foundation; either version 2
-//  of the License, or (at your option) any later version.
-//
-//  This program is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//  GNU General Public License for more details.
-//
-//  You should have received a copy of the GNU General Public License
-//  along with this program; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
-//
-///////////////////////////////////////////////////////////////////////////////
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) 2010 Blender Foundation.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file blender/freestyle/intern/view_map/BoxGrid.cpp
+ *  \ingroup freestyle
+ *  \brief Class to define a cell grid surrounding the projected image of a scene
+ *  \author Alexander Beels
+ *  \date 2011-1-29
+ */
 
-#include "BoxGrid.h"
-
-#include <stdexcept>
 #include <algorithm>
+#include <stdexcept>
+
+#include "BoxGrid.h"
 
 using namespace std;
 
@@ -42,11 +47,12 @@ using namespace std;
 // Cell
 /////////
 
-BoxGrid::Cell::Cell () {}
+BoxGrid::Cell::Cell() {}
 
-BoxGrid::Cell::~Cell () {}
+BoxGrid::Cell::~Cell() {}
 
-void BoxGrid::Cell::setDimensions(real x, real y, real sizeX, real sizeY) {
+void BoxGrid::Cell::setDimensions(real x, real y, real sizeX, real sizeY)
+{
        const real epsilon = 1.0e-06;
        boundary[0] = x - epsilon;
        boundary[1] = x + sizeX + epsilon;
@@ -54,11 +60,13 @@ void BoxGrid::Cell::setDimensions(real x, real y, real sizeX, real sizeY) {
        boundary[3] = y + sizeY + epsilon;
 }
 
-bool BoxGrid::Cell::compareOccludersByShallowestPoint (const BoxGrid::OccluderData* a, const BoxGrid::OccluderData* b) {
+bool BoxGrid::Cell::compareOccludersByShallowestPoint(const BoxGrid::OccluderData *a, const BoxGrid::OccluderData *b)
+{
        return a->shallowest < b->shallowest;
 }
 
-void BoxGrid::Cell::indexPolygons() {
+void BoxGrid::Cell::indexPolygons()
+{
        // Sort occluders by their shallowest points.
        sort(faces.begin(), faces.end(), compareOccludersByShallowestPoint);
 }
@@ -66,47 +74,49 @@ void BoxGrid::Cell::indexPolygons() {
 // Iterator
 //////////////////
 
-BoxGrid::Iterator::Iterator (BoxGrid& grid, Vec3r& center, real epsilon) 
-       : _target(grid.transform(center)), 
-       _foundOccludee(false)
+BoxGrid::Iterator::Iterator (BoxGrid& grid, Vec3r& center, real epsilon)
+: _target(grid.transform(center)), _foundOccludee(false)
 {
        // Find target cell
        _cell = grid.findCell(_target);
-       #if boxgridlogging == 1
-               cout << "Searching for occluders of edge centered at " << _target << " in cell [" 
-                       << _cell->boundary[0] << ", " << _cell->boundary[1] << ", " << _cell->boundary[2] 
-                       << ", " << _cell->boundary[3] << "] (" << _cell->faces.size() << " occluders)" << endl;
+       #if BOX_GRID_LOGGING
+               cout << "Searching for occluders of edge centered at " << _target << " in cell ["
+                    << _cell->boundary[0] << ", " << _cell->boundary[1] << ", " << _cell->boundary[2]
+                    << ", " << _cell->boundary[3] << "] (" << _cell->faces.size() << " occluders)" << endl;
        #endif
 
        // Set iterator
        _current = _cell->faces.begin();
 }
 
-BoxGrid::Iterator::~Iterator () {}
+BoxGrid::Iterator::~Iterator() {}
 
 // BoxGrid
 /////////////////
 
-BoxGrid::BoxGrid(OccluderSource& source, GridDensityProvider& density, ViewMap *viewMap, Vec3r& viewpoint, bool enableQI)
-       : _viewpoint(viewpoint),
-       _enableQI(enableQI)
+BoxGrid::BoxGrid(OccluderSource& source, GridDensityProvider& density, ViewMap *viewMap, Vec3r& viewpoint,
+                 bool enableQI)
+: _viewpoint(viewpoint), _enableQI(enableQI)
 {
-       cout << "Generate Cell structure" << endl;
        // Generate Cell structure
+       cout << "Generate Cell structure" << endl;
        assignCells(source, density, viewMap);
-       cout << "Distribute occluders" << endl;
+
        // Fill Cells
+       cout << "Distribute occluders" << endl;
        distributePolygons(source);
-       cout << "Reorganize cells" << endl;
+
        // Reorganize Cells
+       cout << "Reorganize cells" << endl;
        reorganizeCells();
+
        cout << "Ready to use BoxGrid" << endl;
 }
 
-BoxGrid::~BoxGrid () {
-}
+BoxGrid::~BoxGrid() {}
 
-void BoxGrid::assignCells (OccluderSource& source, GridDensityProvider& density, ViewMap *viewMap) {
+void BoxGrid::assignCells (OccluderSource& source, GridDensityProvider& density, ViewMap *viewMap)
+{
        _cellSize = density.cellSize();
        _cellsX = density.cellsX();
        _cellsY = density.cellsY();
@@ -115,20 +125,19 @@ void BoxGrid::assignCells (OccluderSource& source, GridDensityProvider& density,
 
        // Now allocate the cell table and fill it with default (empty) cells
        _cells.resize(_cellsX * _cellsY);
-       for ( cellContainer::iterator i = _cells.begin(), end = _cells.end(); i != end; ++i ) {
+       for (cellContainer::iterator i = _cells.begin(), end = _cells.end(); i != end; ++i) {
                (*i) = NULL;
        }
 
        // Identify cells that will be used, and set the dimensions for each
        ViewMap::fedges_container& fedges = viewMap->FEdges();
-       for (ViewMap::fedges_container::iterator f = fedges.begin(), fend = fedges.end(); f != fend; ++f ) {
-               if ( (*f)->isInImage() ) {
+       for (ViewMap::fedges_container::iterator f = fedges.begin(), fend = fedges.end(); f != fend; ++f) {
+               if ((*f)->isInImage()) {
                        Vec3r point = transform((*f)->center3d());
-                       unsigned i, j;
+                       unsigned int i, j;
                        getCellCoordinates(point, i, j);
-                       if ( _cells[i * _cellsY + j] == NULL ) {
+                       if (_cells[i * _cellsY + j] == NULL) {
                                // This is an uninitialized cell
-
                                real x, y, width, height;
 
                                x = _cellOrigin[0] + _cellSize * i;
@@ -145,19 +154,21 @@ void BoxGrid::assignCells (OccluderSource& source, GridDensityProvider& density,
        }
 }
 
-void BoxGrid::distributePolygons (OccluderSource& source) {
+void BoxGrid::distributePolygons(OccluderSource& source)
+{
        unsigned long nFaces = 0;
        unsigned long nKeptFaces = 0;
 
-       for ( source.begin(); source.isValid(); source.next() ) {
-               OccluderDataoccluder = NULL;
+       for (source.begin(); source.isValid(); source.next()) {
+               OccluderData *occluder = NULL;
 
                try {
-                       if ( insertOccluder(source, occluder) ) {
+                       if (insertOccluder(source, occluder)) {
                                _faces.push_back(occluder);
                                ++nKeptFaces;
                        }
-               } catch (...) {
+               }
+               catch (...) {
                        // If an exception was thrown, _faces.push_back() cannot have succeeded.
                        // occluder is not owned by anyone, and must be deleted.
                        // If the exception was thrown before or during new OccluderData(), then
@@ -170,41 +181,47 @@ void BoxGrid::distributePolygons (OccluderSource& source) {
        cout << "Distributed " << nFaces << " occluders.  Retained " << nKeptFaces << "." << endl;
 }
 
-void BoxGrid::reorganizeCells () {
+void BoxGrid::reorganizeCells()
+{
        // Sort the occluders by shallowest point
-       for ( vector<Cell*>::iterator i = _cells.begin(), end = _cells.end(); i != end; ++i ) {
-               if ( *i != NULL ) {
+       for (vector<Cell*>::iterator i = _cells.begin(), end = _cells.end(); i != end; ++i) {
+               if (*i != NULL) {
                        (*i)->indexPolygons();
                }
        }
 }
 
-void BoxGrid::getCellCoordinates(const Vec3r& point, unsigned& x, unsigned& y) {
+void BoxGrid::getCellCoordinates(const Vec3r& point, unsigned& x, unsigned& y)
+{
        x = min(_cellsX - 1, (unsigned) floor (max((double) 0.0f, point[0] - _cellOrigin[0]) / _cellSize));
        y = min(_cellsY - 1, (unsigned) floor (max((double) 0.0f, point[1] - _cellOrigin[1]) / _cellSize));
 }
 
-BoxGrid::Cell* BoxGrid::findCell(const Vec3r& point) {
-       unsigned x, y;
+BoxGrid::Cell* BoxGrid::findCell(const Vec3r& point)
+{
+       unsigned int x, y;
        getCellCoordinates(point, x, y);
        return _cells[x * _cellsY + y];
 }
 
-bool BoxGrid::orthographicProjection () const {
+bool BoxGrid::orthographicProjection() const
+{
        return true;
 }
 
-const Vec3r& BoxGrid::viewpoint() const {
+const Vec3r& BoxGrid::viewpoint() const
+{
        return _viewpoint;
 }
 
-bool BoxGrid::enableQI() const {
+bool BoxGrid::enableQI() const
+{
        return _enableQI;
 }
 
-BoxGrid::Transform::Transform () : GridHelpers::Transform() {}
+BoxGrid::Transform::Transform() : GridHelpers::Transform() {}
 
-Vec3r BoxGrid::Transform::operator() (const Vec3r& point) const {
+Vec3r BoxGrid::Transform::operator()(const Vec3r& point) const
+{
        return Vec3r(point[0], point[1], -point[2]);
 }
-
index 43de8d713d55d6fc7a790c044f693e35630212fd..9c8875865efaa8556fb8c55caa90b48351b8ed72 100644 (file)
@@ -1,78 +1,87 @@
-//
-//  Filename         : BoxGrid.h
-//  Author(s)        : Alexander Beels
-//  Purpose          : Class to define a cell grid surrounding
-//                     the projected image of a scene
-//  Date of creation : 2011-1-29
-//
-///////////////////////////////////////////////////////////////////////////////
-
-
-//
-//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
-//   with this source distribution. 
-//
-//  This program is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU General Public License
-//  as published by the Free Software Foundation; either version 2
-//  of the License, or (at your option) any later version.
-//
-//  This program is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//  GNU General Public License for more details.
-//
-//  You should have received a copy of the GNU General Public License
-//  along with this program; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef BOXGRID_H
-#define BOXGRID_H
-
-#define boxgridlogging 0
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) 2010 Blender Foundation.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#ifndef __FREESTYLE_BOX_GRID_H__
+#define __FREESTYLE_BOX_GRID_H__
+
+/** \file blender/freestyle/intern/view_map/BoxGrid.h
+ *  \ingroup freestyle
+ *  \brief Class to define a cell grid surrounding the projected image of a scene
+ *  \author Alexander Beels
+ *  \date 2011-1-29
+ */
+
+#define BOX_GRID_LOGGING FALSE
 
 // I would like to avoid using deque because including ViewMap.h and <deque> or <vector>
-// separately results in redefinitions of identifiers.  ViewMap.h already includes <vector> 
+// separately results in redefinitions of identifiers. ViewMap.h already includes <vector>
 // so it should be a safe fall-back.
 //#include <vector>
 //#include <deque>
+
+#include "GridDensityProvider.h"
+#include "OccluderSource.h"
 #include "ViewMap.h"
-#include "../winged_edge/WEdge.h"
-#include "../geometry/Polygon.h"
-#include "../system/PointerSequence.h"
+
 #include "../geometry/BBox.h"
 #include "../geometry/GridHelpers.h"
-#include "OccluderSource.h"
-#include "GridDensityProvider.h"
+#include "../geometry/Polygon.h"
+
+#include "../system/PointerSequence.h"
+
+#include "../winged_edge/WEdge.h"
 
 class BoxGrid
 {
 public:
        // Helper classes
-       struct OccluderData {
-               explicit OccluderData (OccluderSource& source, Polygon3r& p);
+       struct OccluderData
+       {
+               explicit OccluderData(OccluderSource& source, Polygon3r& p);
                Polygon3r poly;
                Polygon3r cameraSpacePolygon;
                real shallowest, deepest;
-               // N.B. We could, of course, store face in poly's userdata
-               // member, like the old ViewMapBuilder code does.  However,
-               // code comments make it clear that userdata is deprecated,
-               // so we avoid the temptation to save 4 or 8 bytes.
+               // N.B. We could, of course, store face in poly's userdata member, like the old ViewMapBuilder code does.
+               // However, code comments make it clear that userdata is deprecated, so we avoid the temptation
+               // to save 4 or 8 bytes.
                WFace* face;
        };
 
 private:
-       struct Cell {
+       struct Cell
+       {
                // Can't store Cell in a vector without copy and assign
-               //Cell(const Cell& other);
-               //Cell& operator= (const Cell& other);
+               // Cell(const Cell& other);
+               // Cell& operator=(const Cell& other);
 
-               explicit Cell ();
-               ~Cell ();
+               explicit Cell();
+               ~Cell();
 
-               static bool compareOccludersByShallowestPoint (const OccluderData* a, const OccluderData* b);
+               static bool compareOccludersByShallowestPoint(const OccluderData *a, const OccluderData *b);
 
                void setDimensions(real x, real y, real sizeX, real sizeY);
                void checkAndInsert(OccluderSource& source, Polygon3r& poly, OccluderData*& occluder);
@@ -84,43 +93,37 @@ private:
        };
 
 public:
-       /*****
-
-       Iterator needs to allow the user to avoid full 3D comparison in
-       two cases:
-
-       (1) Where (*current)->deepest < target[2], where the occluder is 
-       unambiguously in front of the target point.
-
-       (2) Where (*current)->shallowest > target[2], where the occluder
-       is unambiguously in back of the target point.
-
-       In addition, when used by OptimizedFindOccludee, Iterator should
-       stop iterating as soon as it has an occludee candidate and 
-       (*current)->shallowest > candidate[2], because at that point forward
-       no new occluder could possibly be a better occludee.
-
-       *****/
-
-       class Iterator {
+       /* Iterator needs to allow the user to avoid full 3D comparison in two cases:
+        *
+        * (1) Where (*current)->deepest < target[2], where the occluder is unambiguously in front of the target point.
+        *
+        * (2) Where (*current)->shallowest > target[2], where the occluder is unambiguously in back of the target point.
+        *
+        * In addition, when used by OptimizedFindOccludee, Iterator should stop iterating as soon as it has an
+        * occludee candidate and (*current)->shallowest > candidate[2], because at that point forward no new occluder
+        * could possibly be a better occludee.
+        */
+       class Iterator
+       {
        public:
                // epsilon is not used in this class, but other grids with the same interface may need an epsilon
-               explicit Iterator (BoxGrid& grid, Vec3r& center, real epsilon=1e-06);
-               ~Iterator ();
-               void initBeforeTarget ();
-               void initAfterTarget ();
-               void nextOccluder ();
-               void nextOccludee ();
+               explicit Iterator(BoxGrid& grid, Vec3r& center, real epsilon = 1.0e-06);
+               ~Iterator();
+               void initBeforeTarget();
+               void initAfterTarget();
+               void nextOccluder();
+               void nextOccludee();
                bool validBeforeTarget();
                bool validAfterTarget();
-               WFacegetWFace() const;
-               Polygon3rgetCameraSpacePolygon();
+               WFace *getWFace() const;
+               Polygon3r *getCameraSpacePolygon();
                void reportDepth(Vec3r origin, Vec3r u, real t);
+
        private:
                bool testOccluder(bool wantOccludee);
                void markCurrentOccludeeCandidate(real depth);
 
-               Cell_cell;
+               Cell *_cell;
                Vec3r _target;
                bool _foundOccludee;
                real _occludeeDepth;
@@ -128,37 +131,39 @@ public:
                vector<OccluderData*>::iterator _current, _occludeeCandidate;
        };
 
-       class Transform : public GridHelpers::Transform {
+       class Transform : public GridHelpers::Transform
+       {
        public:
-               explicit Transform ();
-               explicit Transform (Transform& other);
-               Vec3r operator() (const Vec3r& point) const;
+               explicit Transform();
+               explicit Transform(Transform& other);
+               Vec3r operator()(const Vec3r& point) const;
        };
 
 private:
        // Prevent implicit copies and assignments.
        BoxGrid(const BoxGrid& other);
-       BoxGrid& operator= (const BoxGrid& other);
+       BoxGrid& operator=(const BoxGrid& other);
+
 public:
-       explicit BoxGrid (OccluderSource& source, GridDensityProvider& density, ViewMap *viewMap, Vec3r& viewpoint, bool enableQI);
+       explicit BoxGrid(OccluderSource& source, GridDensityProvider& density, ViewMap *viewMap, Vec3r& viewpoint,
+                        bool enableQI);
        virtual ~BoxGrid();
 
        // Generate Cell structure
        void assignCells(OccluderSource& source, GridDensityProvider& density, ViewMap *viewMap);
        // Fill Cells
        void distributePolygons(OccluderSource& source);
-       // Insert one polygon into each matching cell, 
-       // return true if any cell consumes the polygon
+       // Insert one polygon into each matching cell, return true if any cell consumes the polygon
        bool insertOccluder(OccluderSource& source, OccluderData*& occluder);
        // Sort occluders in each cell
        void reorganizeCells();
 
-       CellfindCell(const Vec3r& point);
+       Cell *findCell(const Vec3r& point);
 
        // Accessors:
        bool orthographicProjection() const;
        const Vec3r& viewpoint() const;
-       bool enableQI() const; 
+       bool enableQI() const;
        Transform transform;
 
 private:
@@ -176,51 +181,52 @@ private:
        bool _enableQI;
 };
 
-inline void BoxGrid::Iterator::initBeforeTarget () {
+inline void BoxGrid::Iterator::initBeforeTarget()
+{
        _current = _cell->faces.begin();
-       while ( _current != _cell->faces.end() && ! testOccluder(false) ) {
+       while (_current != _cell->faces.end() && !testOccluder(false)) {
                ++_current;
        }
 }
 
-inline void BoxGrid::Iterator::initAfterTarget () {
-       if ( _foundOccludee ) {
-               #if boxgridlogging == 1
+inline void BoxGrid::Iterator::initAfterTarget()
+{
+       if (_foundOccludee) {
+               #if BOX_GRID_LOGGING
                        std::cout << "\tStarting occludee search from occludeeCandidate at depth " << _occludeeDepth << std::endl;
                #endif
                _current = _occludeeCandidate;
                return;
        }
 
-       #if boxgridlogging == 1
+       #if BOX_GRID_LOGGING
                std::cout << "\tStarting occludee search from current position" << std::endl;
        #endif
 
-       while ( _current != _cell->faces.end() && ! testOccluder(true) ) {
+       while (_current != _cell->faces.end() && !testOccluder(true)) {
                ++_current;
        }
 }
 
-inline bool BoxGrid::Iterator::testOccluder (bool wantOccludee) {
+inline bool BoxGrid::Iterator::testOccluder(bool wantOccludee)
+{
        // End-of-list is not even a valid iterator position
-       if ( _current == _cell->faces.end() ) {
-               // Returning true seems strange, but it will break us out of whatever loop
-               // is calling testOccluder, and _current=_cell->face.end() will make
-               // the calling routine give up.
+       if (_current == _cell->faces.end()) {
+               // Returning true seems strange, but it will break us out of whatever loop is calling testOccluder,
+               // and _current = _cell->face.end() will make the calling routine give up.
                return true;
        }
-       #if boxgridlogging == 1
+       #if BOX_GRID_LOGGING
                std::cout << "\tTesting occluder " << (*_current)->poly.getVertices()[0];
-               for ( unsigned i = 1; i < (*_current)->poly.getVertices().size(); ++i ) {
+               for (unsigned int i = 1; i < (*_current)->poly.getVertices().size(); ++i) {
                        std::cout << ", " << (*_current)->poly.getVertices()[i];
                }
                std::cout << " from shape " << (*_current)->face->GetVertex(0)->shape()->GetId() << std::endl;
        #endif
 
-
        // If we have an occluder candidate and we are unambiguously after it, abort
-       if ( _foundOccludee && (*_current)->shallowest > _occludeeDepth ) {
-               #if boxgridlogging == 1
+       if (_foundOccludee && (*_current)->shallowest > _occludeeDepth) {
+               #if BOX_GRID_LOGGING
                        std::cout << "\t\tAborting: shallowest > occludeeCandidate->deepest" << std::endl;
                #endif
                _current = _cell->faces.end();
@@ -230,16 +236,17 @@ inline bool BoxGrid::Iterator::testOccluder (bool wantOccludee) {
        }
 
        // Specific continue or stop conditions when searching for each type
-       if ( wantOccludee ) {
-               if ( (*_current)->deepest < _target[2] ) {
-                       #if boxgridlogging == 1
+       if (wantOccludee) {
+               if ((*_current)->deepest < _target[2]) {
+                       #if BOX_GRID_LOGGING
                                std::cout << "\t\tSkipping: shallower than target while looking for occludee" << std::endl;
                        #endif
                        return false;
                }
-       } else {
-               if ( (*_current)->shallowest > _target[2] ) {
-                       #if boxgridlogging == 1
+       }
+       else {
+               if ((*_current)->shallowest > _target[2]) {
+                       #if BOX_GRID_LOGGING
                                std::cout << "\t\tStopping: deeper than target while looking for occluder" << std::endl;
                        #endif
                        return true;
@@ -251,67 +258,73 @@ inline bool BoxGrid::Iterator::testOccluder (bool wantOccludee) {
        // Check to see if target is in the 2D bounding box
        Vec3r bbMin, bbMax;
        (*_current)->poly.getBBox(bbMin, bbMax);
-       if ( _target[0] < bbMin[0] || _target[0] > bbMax[0] || _target[1] < bbMin[1] || _target[1] > bbMax[1] ) {
-               #if boxgridlogging == 1
+       if (_target[0] < bbMin[0] || _target[0] > bbMax[0] || _target[1] < bbMin[1] || _target[1] > bbMax[1]) {
+               #if BOX_GRID_LOGGING
                        std::cout << "\t\tSkipping: bounding box violation" << std::endl;
                #endif
                return false;
        }
 
        // We've done all the corner cutting we can.
-       // Let the caller work out whether or not
-       // the geometry is correct.
+       // Let the caller work out whether or not the geometry is correct.
        return true;
 }
 
-inline void BoxGrid::Iterator::reportDepth (Vec3r origin, Vec3r u, real t) {
+inline void BoxGrid::Iterator::reportDepth(Vec3r origin, Vec3r u, real t)
+{
        // The reported depth is the length of a ray in camera space
        // We need to convert it into a Z-value in grid space
        real depth = -(origin + (u * t))[2];
-       #if boxgridlogging == 1
+       #if BOX_GRID_LOGGING
                std::cout << "\t\tReporting depth of occluder/ee: " << depth;
        #endif
-       if ( depth > _target[2] ) {
-               #if boxgridlogging == 1
+       if (depth > _target[2]) {
+               #if BOX_GRID_LOGGING
                        std::cout << " is deeper than target" << std::endl;
                #endif
                // If the current occluder is the best occludee so far, save it.
-               if ( ! _foundOccludee || _occludeeDepth > depth ) {
+               if (! _foundOccludee || _occludeeDepth > depth) {
                        markCurrentOccludeeCandidate(depth);
-               } 
-       } else {
-               #if boxgridlogging == 1
+               }
+       }
+       else {
+               #if BOX_GRID_LOGGING
                        std::cout << std::endl;
                #endif
        }
 }
 
-inline void BoxGrid::Iterator::nextOccluder () {
-       if ( _current != _cell->faces.end() ) {
+inline void BoxGrid::Iterator::nextOccluder()
+{
+       if (_current != _cell->faces.end()) {
                do {
                        ++_current;
-               } while ( _current != _cell->faces.end() && ! testOccluder(false) );
+               } while (_current != _cell->faces.end() && ! testOccluder(false));
        }
 }
 
-inline void BoxGrid::Iterator::nextOccludee () {
-       if ( _current != _cell->faces.end() ) {
+inline void BoxGrid::Iterator::nextOccludee()
+{
+       if (_current != _cell->faces.end()) {
                do {
                        ++_current;
-               } while ( _current != _cell->faces.end() && ! testOccluder(true) );
+               } while (_current != _cell->faces.end() && ! testOccluder(true));
        }
 }
 
-inline bool BoxGrid::Iterator::validBeforeTarget () {
+inline bool BoxGrid::Iterator::validBeforeTarget()
+{
        return _current != _cell->faces.end() && (*_current)->shallowest <= _target[2];
 }
 
-inline bool BoxGrid::Iterator::validAfterTarget () {
+inline bool BoxGrid::Iterator::validAfterTarget()
+{
        return _current != _cell->faces.end();
 }
 
-inline void BoxGrid::Iterator::markCurrentOccludeeCandidate(real depth) {
-       #if boxgridlogging == 1
+inline void BoxGrid::Iterator::markCurrentOccludeeCandidate(real depth)
+{
+       #if BOX_GRID_LOGGING
                std::cout << "\t\tFound occludeeCandidate at depth " << depth << std::endl;
        #endif
        _occludeeCandidate = _current;
@@ -319,18 +332,20 @@ inline void BoxGrid::Iterator::markCurrentOccludeeCandidate(real depth) {
        _foundOccludee = true;
 }
 
-inline WFace* BoxGrid::Iterator::getWFace() const {
+inline WFace* BoxGrid::Iterator::getWFace() const
+{
        return (*_current)->face;
 }
 
-inline Polygon3r* BoxGrid::Iterator::getCameraSpacePolygon() {
+inline Polygon3r* BoxGrid::Iterator::getCameraSpacePolygon()
+{
        return &((*_current)->cameraSpacePolygon);
 }
 
-inline BoxGrid::OccluderData::OccluderData (OccluderSource& source, Polygon3r& p)
-       : poly(p), 
-       cameraSpacePolygon(source.getCameraSpacePolygon()),
-       face(source.getWFace())
+inline BoxGrid::OccluderData::OccluderData(OccluderSource& source, Polygon3r& p)
+: poly(p),
+  cameraSpacePolygon(source.getCameraSpacePolygon()),
+  face(source.getWFace())
 {
        // Set shallowest and deepest based on bbox
        Vec3r min, max;
@@ -339,9 +354,10 @@ inline BoxGrid::OccluderData::OccluderData (OccluderSource& source, Polygon3r& p
        deepest = max[2];
 }
 
-inline void BoxGrid::Cell::checkAndInsert(OccluderSource& source, Polygon3r& poly, OccluderData*& occluder) {
-       if ( GridHelpers::insideProscenium (boundary, poly) ) {
-               if ( occluder == NULL) {
+inline void BoxGrid::Cell::checkAndInsert(OccluderSource& source, Polygon3r& poly, OccluderData*& occluder)
+{
+       if (GridHelpers::insideProscenium (boundary, poly)) {
+               if (occluder == NULL) {
                        // Disposal of occluder will be handled in BoxGrid::distributePolygons(),
                        // or automatically by BoxGrid::_faces;
                        occluder = new OccluderData(source, poly);
@@ -350,7 +366,8 @@ inline void BoxGrid::Cell::checkAndInsert(OccluderSource& source, Polygon3r& pol
        }
 }
 
-inline bool BoxGrid::insertOccluder(OccluderSource& source, OccluderData*& occluder) {
+inline bool BoxGrid::insertOccluder(OccluderSource& source, OccluderData*& occluder)
+{
        Polygon3r& poly(source.getGridSpacePolygon());
        occluder = NULL;
 
@@ -361,9 +378,9 @@ inline bool BoxGrid::insertOccluder(OccluderSource& source, OccluderData*& occlu
        getCellCoordinates(bbMin, startX, startY);
        getCellCoordinates(bbMax, endX, endY);
 
-       for ( unsigned i = startX; i <= endX; ++i ) {
-               for ( unsigned j = startY; j <= endY; ++j ) {
-                       if ( _cells[i * _cellsY + j] != NULL ) {
+       for (unsigned int i = startX; i <= endX; ++i) {
+               for (unsigned int j = startY; j <= endY; ++j) {
+                       if (_cells[i * _cellsY + j] != NULL) {
                                _cells[i * _cellsY + j]->checkAndInsert(source, poly, occluder);
                        }
                }
@@ -372,5 +389,4 @@ inline bool BoxGrid::insertOccluder(OccluderSource& source, OccluderData*& occlu
        return occluder != NULL;
 }
 
-#endif // BOXGRID_H
-
+#endif // __FREESTYLE_BOX_GRID_H__
index ea57da9334748fdcb9e8603b1647a6e8ab62dcca..0e01a70181a7ee84b7d5b575336e990069f026c8 100644 (file)
@@ -1,67 +1,74 @@
-//
-//  Filename         : CulledOccluderSource.h
-//  Author(s)        : Alexander Beels
-//  Purpose          : Class to define a cell grid surrounding
-//                     the projected image of a scene
-//  Date of creation : 2010-12-21
-//
-///////////////////////////////////////////////////////////////////////////////
-
-
-//
-//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
-//   with this source distribution. 
-//
-//  This program is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU General Public License
-//  as published by the Free Software Foundation; either version 2
-//  of the License, or (at your option) any later version.
-//
-//  This program is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//  GNU General Public License for more details.
-//
-//  You should have received a copy of the GNU General Public License
-//  along with this program; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
-//
-///////////////////////////////////////////////////////////////////////////////
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) 2010 Blender Foundation.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file blender/freestyle/intern/view_map/CulledOccluderSource.cpp
+ *  \ingroup freestyle
+ *  \brief Class to define a cell grid surrounding the projected image of a scene
+ *  \author Alexander Beels
+ *  \date 2010-12-21
+ */
 
 #include "CulledOccluderSource.h"
-#include "../geometry/GridHelpers.h"
+
 #include "FRS_freestyle.h"
 
-CulledOccluderSource::CulledOccluderSource (const GridHelpers::Transform& t, WingedEdge& we, ViewMap& viewMap, bool extensiveFEdgeSearch) 
-       : OccluderSource(t, we), 
-       rejected(0),
-       gridSpaceOccluderProsceniumInitialized(false)
+#include "../geometry/GridHelpers.h"
+
+CulledOccluderSource::CulledOccluderSource(const GridHelpers::Transform& t, WingedEdge& we, ViewMap& viewMap,
+                                           bool extensiveFEdgeSearch)
+: OccluderSource(t, we), rejected(0), gridSpaceOccluderProsceniumInitialized(false)
 {
        cullViewEdges(viewMap, extensiveFEdgeSearch);
 
-       // If we have not found any visible FEdges during our cull, then there is nothing
-       // to iterate over.  Short-circuit everything.
+       // If we have not found any visible FEdges during our cull, then there is nothing to iterate over.
+       // Short-circuit everything.
        valid = gridSpaceOccluderProsceniumInitialized;
 
-       if ( valid && ! testCurrent() ) {
+       if (valid && ! testCurrent()) {
                next();
        }
 }
 
-CulledOccluderSource::~CulledOccluderSource() {
-}
+CulledOccluderSource::~CulledOccluderSource() {}
 
-bool CulledOccluderSource::testCurrent() {
-       if ( valid ) {
+bool CulledOccluderSource::testCurrent()
+{
+       if (valid) {
                // The test for gridSpaceOccluderProsceniumInitialized should not be necessary
-               return gridSpaceOccluderProsceniumInitialized && GridHelpers::insideProscenium (gridSpaceOccluderProscenium, cachedPolygon);
+               return gridSpaceOccluderProsceniumInitialized &&
+                      GridHelpers::insideProscenium(gridSpaceOccluderProscenium, cachedPolygon);
        }
        return false;
 }
 
-bool CulledOccluderSource::next() {
-       while ( OccluderSource::next() ) {
-               if ( testCurrent() ) {
+bool CulledOccluderSource::next()
+{
+       while (OccluderSource::next()) {
+               if (testCurrent()) {
                        ++rejected;
                        return true;
                }
@@ -70,17 +77,20 @@ bool CulledOccluderSource::next() {
        return false;
 }
 
-void CulledOccluderSource::getOccluderProscenium(real proscenium[4]) {
-       for ( unsigned i = 0; i < 4; ++i ) {
+void CulledOccluderSource::getOccluderProscenium(real proscenium[4])
+{
+       for (unsigned int i = 0; i < 4; ++i) {
                proscenium[i] = gridSpaceOccluderProscenium[i];
        }
 }
 
-static inline real distance2D(const Vec3r & point, const real origin[2]) {
+static inline real distance2D(const Vec3r & point, const real origin[2])
+{
        return ::hypot((point[0] - origin[0]), (point[1] - origin[1]));
 }
 
-static inline bool crossesProscenium(real proscenium[4], FEdge *fe) {
+static inline bool crossesProscenium(real proscenium[4], FEdge *fe)
+{
        Vec2r min(proscenium[0], proscenium[2]);
        Vec2r max(proscenium[1], proscenium[3]);
        Vec2r A(fe->vertexA()->getProjectedX(), fe->vertexA()->getProjectedY());
@@ -89,20 +99,20 @@ static inline bool crossesProscenium(real proscenium[4], FEdge *fe) {
        return GeomUtils::intersect2dSeg2dArea (min, max, A, B);
 }
 
-static inline bool insideProscenium(real proscenium[4], const Vec3r& point) {
-       return ! ( point[0] < proscenium[0] || point[0] > proscenium[1] || point[1] < proscenium[2] || point[1] > proscenium[3] );
+static inline bool insideProscenium(real proscenium[4], const Vec3r& point)
+{
+       return !(point[0] < proscenium[0] || point[0] > proscenium[1] ||
+                point[1] < proscenium[2] || point[1] > proscenium[3]);
 }
 
-void CulledOccluderSource::cullViewEdges(ViewMap& viewMap, bool extensiveFEdgeSearch) {
+void CulledOccluderSource::cullViewEdges(ViewMap& viewMap, bool extensiveFEdgeSearch)
+{
        // Cull view edges by marking them as non-displayable.
-       // This avoids the complications of trying to delete
-       // edges from the ViewMap.
+       // This avoids the complications of trying to delete edges from the ViewMap.
 
-       // Non-displayable view edges will be skipped over during
-       // visibility calculation.
+       // Non-displayable view edges will be skipped over during visibility calculation.
 
-       // View edges will be culled according to their position
-       // w.r.t. the viewport proscenium (viewport + 5% border,
+       // View edges will be culled according to their position w.r.t. the viewport proscenium (viewport + 5% border,
        // or some such).
 
        // Get proscenium boundary for culling
@@ -112,34 +122,30 @@ void CulledOccluderSource::cullViewEdges(ViewMap& viewMap, bool extensiveFEdgeSe
        prosceniumOrigin[0] = (viewProscenium[1] - viewProscenium[0]) / 2.0;
        prosceniumOrigin[1] = (viewProscenium[3] - viewProscenium[2]) / 2.0;
        cout << "Proscenium culling:" << endl;
-       cout << "Proscenium: [" << viewProscenium[0] << ", " << viewProscenium[1] << ", " << viewProscenium[2] << ", " << viewProscenium[3] << "]"<< endl;
+       cout << "Proscenium: [" << viewProscenium[0] << ", " << viewProscenium[1] << ", " << viewProscenium[2]
+            << ", " << viewProscenium[3] << "]"<< endl;
        cout << "Origin: [" << prosceniumOrigin[0] << ", " << prosceniumOrigin[1] << "]"<< endl;
        
-       // A separate occluder proscenium will also be maintained,
-       // starting out the same as the viewport proscenium, and 
-       // expanding as necessary so that it encompasses the center 
-       // point of at least one feature edge in each retained view
-       // edge.
-       // The occluder proscenium will be used later to cull occluding
-       // triangles before they are inserted into the Grid.
-       // The occluder proscenium starts out the same size as the view
-       // proscenium
+       // A separate occluder proscenium will also be maintained, starting out the same as the viewport proscenium, and
+       // expanding as necessary so that it encompasses the center point of at least one feature edge in each
+       // retained view edge.
+       // The occluder proscenium will be used later to cull occluding triangles before they are inserted into the Grid.
+       // The occluder proscenium starts out the same size as the view proscenium
        GridHelpers::getDefaultViewProscenium(occluderProscenium);
 
-       // N.B. Freestyle is inconsistent in its use of ViewMap::viewedges_container
-       // and vector<ViewEdge*>::iterator.  Probably all occurences of vector<ViewEdge*>::iterator
-       // should be replaced ViewMap::viewedges_container throughout the code.
+       // XXX Freestyle is inconsistent in its use of ViewMap::viewedges_container and vector<ViewEdge*>::iterator.
+       // Probably all occurences of vector<ViewEdge*>::iterator should be replaced ViewMap::viewedges_container
+       // throughout the code.
        // For each view edge
        ViewMap::viewedges_container::iterator ve, veend;
 
-       for(ve=viewMap.ViewEdges().begin(), veend=viewMap.ViewEdges().end(); ve!=veend; ve++) {
+       for (ve = viewMap.ViewEdges().begin(), veend = viewMap.ViewEdges().end(); ve != veend; ve++) {
                // Overview:
                //    Search for a visible feature edge
                //    If none: mark view edge as non-displayable
                //    Otherwise:
                //        Find a feature edge with center point inside occluder proscenium.
-               //        If none exists, find the feature edge with center point
-               //            closest to viewport origin.
+               //        If none exists, find the feature edge with center point closest to viewport origin.
                //            Expand occluder proscenium to enclose center point.
 
                // For each feature edge, while bestOccluderTarget not found and view edge not visibile
@@ -151,28 +157,27 @@ void CulledOccluderSource::cullViewEdges(ViewMap& viewMap, bool extensiveFEdgeSe
                // All ViewEdges start culled
                (*ve)->setIsInImage(false);
 
-               // For simple visibility calculation: mark a feature edge
-               // that is known to have a center point inside the occluder proscenium.  
-               // Cull all other feature edges.
+               // For simple visibility calculation: mark a feature edge that is known to have a center point inside
+               // the occluder proscenium. Cull all other feature edges.
                do {
                        // All FEdges start culled
                        fe->setIsInImage(false);
 
-                       // Look for the visible edge that can most easily be included
-                       // in the occluder proscenium.
-                       if ( ! bestOccluderTargetFound ) {
-                               // If center point is inside occluder proscenium, 
-                               if ( insideProscenium(occluderProscenium, fe->center2d()) ) {
+                       // Look for the visible edge that can most easily be included in the occluder proscenium.
+                       if (!bestOccluderTargetFound) {
+                               // If center point is inside occluder proscenium,
+                               if (insideProscenium(occluderProscenium, fe->center2d())) {
                                        // Use this feature edge for visibility deterimination
                                        fe->setIsInImage(true);
                                        expandGridSpaceOccluderProscenium(fe);
                                        // Mark bestOccluderTarget as found
                                        bestOccluderTargetFound = true;
                                        bestOccluderTarget = fe;
-                               } else {
+                               }
+                               else {
                                        real d = distance2D(fe->center2d(), prosceniumOrigin);
                                        // If center point is closer to viewport origin than current target
-                                       if ( bestOccluderTarget == NULL || d < bestOccluderDistance ) {
+                                       if (bestOccluderTarget == NULL || d < bestOccluderDistance) {
                                                // Then store as bestOccluderTarget
                                                bestOccluderDistance = d;
                                                bestOccluderTarget = fe;
@@ -181,33 +186,35 @@ void CulledOccluderSource::cullViewEdges(ViewMap& viewMap, bool extensiveFEdgeSe
                        }
 
                        // If feature edge crosses the view proscenium
-                       if ( ! (*ve)->isInImage() && crossesProscenium(viewProscenium, fe) ) {
+                       if (!(*ve)->isInImage() && crossesProscenium(viewProscenium, fe)) {
                                // Then the view edge will be included in the image
                                (*ve)->setIsInImage(true);
                        }
                        fe = fe->nextEdge();
-               } while ( fe != NULL && fe != festart && ! ( bestOccluderTargetFound && (*ve)->isInImage() ) );
+               } while (fe != NULL && fe != festart && !(bestOccluderTargetFound && (*ve)->isInImage()));
 
                // Either we have run out of FEdges, or we already have the one edge we need to determine visibility
                // Cull all remaining edges.
-               while ( fe != NULL && fe != festart ) {
+               while (fe != NULL && fe != festart) {
                        fe->setIsInImage(false);
                        fe = fe->nextEdge();
                }
 
                // If bestOccluderTarget was not found inside the occluder proscenium, 
                // we need to expand the occluder proscenium to include it.
-               if ( (*ve)->isInImage() && bestOccluderTarget != NULL && ! bestOccluderTargetFound ) {
+               if ((*ve)->isInImage() && bestOccluderTarget != NULL && ! bestOccluderTargetFound) {
                        // Expand occluder proscenium to enclose bestOccluderTarget
                        Vec3r point = bestOccluderTarget->center2d();
-                       if ( point[0] < occluderProscenium[0] ) {
+                       if (point[0] < occluderProscenium[0]) {
                                occluderProscenium[0] = point[0];
-                       } else if ( point[0] > occluderProscenium[1] ) {
+                       }
+                       else if (point[0] > occluderProscenium[1]) {
                                occluderProscenium[1] = point[0];
                        }
-                       if ( point[1] < occluderProscenium[2] ) {
+                       if (point[1] < occluderProscenium[2]) {
                                occluderProscenium[2] = point[1];
-                       } else if ( point[1] > occluderProscenium[3] ) {
+                       }
+                       else if (point[1] > occluderProscenium[3]) {
                                occluderProscenium[3] = point[1];
                        }
                        // Use bestOccluderTarget for visibility determination
@@ -225,22 +232,18 @@ void CulledOccluderSource::cullViewEdges(ViewMap& viewMap, bool extensiveFEdgeSe
 
        // For "Normal" or "Fast" style visibility computation only:
 
-       // For more detailed visibility calculation, make a second pass through
-       // the view map, marking all feature edges with center points inside
-       // the final occluder proscenium.  All of these feature edges can be
-       // considered during visibility calculation.
-
-       // So far we have only found one FEdge per ViewEdge.  The "Normal" and
-       // "Fast" styles of visibility computation want to consider many
-       // FEdges for each ViewEdge.
-       // Here we re-scan the view map to find any usable FEdges that we
-       // skipped on the first pass, or that have become usable because the
-       // occluder proscenium has been expanded since the edge was visited
-       // on the first pass.
-       if ( extensiveFEdgeSearch ) {
+       // For more detailed visibility calculation, make a second pass through the view map, marking all feature edges
+       // with center points inside the final occluder proscenium. All of these feature edges can be considered during
+       // visibility calculation.
+
+       // So far we have only found one FEdge per ViewEdge. The "Normal" and "Fast" styles of visibility computation
+       // want to consider many FEdges for each ViewEdge.
+       // Here we re-scan the view map to find any usable FEdges that we skipped on the first pass, or that have become
+       // usable because the occluder proscenium has been expanded since the edge was visited on the first pass.
+       if (extensiveFEdgeSearch) {
                // For each view edge,
-               for(ve=viewMap.ViewEdges().begin(), veend=viewMap.ViewEdges().end(); ve!=veend; ve++) {
-                       if ( ! (*ve)->isInImage() ) {
+               for (ve = viewMap.ViewEdges().begin(), veend = viewMap.ViewEdges().end(); ve != veend; ve++) {
+                       if (!(*ve)->isInImage()) {
                                continue;
                        }
                        // For each feature edge,
@@ -248,30 +251,31 @@ void CulledOccluderSource::cullViewEdges(ViewMap& viewMap, bool extensiveFEdgeSe
                        FEdge *fe = festart;
                        do {
                                // If not (already) visible and center point inside occluder proscenium, 
-                               if ( ! fe->isInImage() && insideProscenium(occluderProscenium, fe->center2d()) ) {
+                               if (!fe->isInImage() && insideProscenium(occluderProscenium, fe->center2d())) {
                                        // Use the feature edge for visibility determination
                                        fe->setIsInImage(true);
                                        expandGridSpaceOccluderProscenium(fe);
                                }
                                fe = fe->nextEdge();
-                       } while ( fe != NULL && fe != festart );
+                       } while (fe != NULL && fe != festart);
                }
        }
 
        // Up until now, all calculations have been done in camera space.
-       // However, the occluder source's iteration and the grid that consumes the occluders
-       // both work in gridspace, so we need a version of the occluder proscenium in gridspace.
+       // However, the occluder source's iteration and the grid that consumes the occluders both work in gridspace,
+       // so we need a version of the occluder proscenium in gridspace.
        // Set the gridspace occlude proscenium
 }
 
-void CulledOccluderSource::expandGridSpaceOccluderProscenium(FEdge* fe) {
-       if ( gridSpaceOccluderProsceniumInitialized ) {
-               GridHelpers::expandProscenium (gridSpaceOccluderProscenium, transform(fe->center3d()));
-       } else {
+void CulledOccluderSource::expandGridSpaceOccluderProscenium(FEdge *fe)
+{
+       if (gridSpaceOccluderProsceniumInitialized) {
+               GridHelpers::expandProscenium(gridSpaceOccluderProscenium, transform(fe->center3d()));
+       }
+       else {
                const Vec3r& point = transform(fe->center3d());
                gridSpaceOccluderProscenium[0] = gridSpaceOccluderProscenium[1] = point[0];
                gridSpaceOccluderProscenium[2] = gridSpaceOccluderProscenium[3] = point[1];
                gridSpaceOccluderProsceniumInitialized = true;
        }
 }
-
index 3c00d5e34ad414d7d8c75c1fb3c7944c321d3a8d..a9c5484ca9c0685db5201a0f5ee8dfbd1acbad21 100644 (file)
@@ -1,46 +1,52 @@
-//
-//  Filename         : CulledOccluderSource.h
-//  Author(s)        : Alexander Beels
-//  Purpose          : Class to define a cell grid surrounding
-//                     the projected image of a scene
-//  Date of creation : 2010-12-21
-//
-///////////////////////////////////////////////////////////////////////////////
-
-
-//
-//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
-//   with this source distribution. 
-//
-//  This program is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU General Public License
-//  as published by the Free Software Foundation; either version 2
-//  of the License, or (at your option) any later version.
-//
-//  This program is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//  GNU General Public License for more details.
-//
-//  You should have received a copy of the GNU General Public License
-//  along with this program; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef CULLEDOCCLUDERSOURCE_H
-#define CULLEDOCCLUDERSOURCE_H
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) 2010 Blender Foundation.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#ifndef __FREESTYLE_CULLED_OCCLUDER_SOURCE_H__
+#define __FREESTYLE_CULLED_OCCLUDER_SOURCE_H__
+
+/** \file blender/freestyle/intern/view_map/CulledOccluderSource.h
+ *  \ingroup freestyle
+ *  \brief Class to define a cell grid surrounding the projected image of a scene
+ *  \author Alexander Beels
+ *  \date 2010-12-21
+ */
 
 #include "OccluderSource.h"
 #include "ViewMap.h"
 
-class CulledOccluderSource : public OccluderSource {
+class CulledOccluderSource : public OccluderSource
+{
        // Disallow copying and assignment
-       CulledOccluderSource (const CulledOccluderSource& other);
-       CulledOccluderSource& operator= (const CulledOccluderSource& other);
+       CulledOccluderSource(const CulledOccluderSource& other);
+       CulledOccluderSource& operator=(const CulledOccluderSource& other);
 
 public:
-       CulledOccluderSource (const GridHelpers::Transform& transform, WingedEdge& we, ViewMap& viewMap, bool extensiveFEdgeSearch = true);
+       CulledOccluderSource(const GridHelpers::Transform& transform, WingedEdge& we, ViewMap& viewMap,
+                            bool extensiveFEdgeSearch = true);
        virtual ~CulledOccluderSource();
 
        void cullViewEdges(ViewMap& viewMap, bool extensiveFEdgeSearch);
@@ -51,7 +57,7 @@ public:
 
 private:
        bool testCurrent();
-       void expandGridSpaceOccluderProscenium(FEdgefe);
+       void expandGridSpaceOccluderProscenium(FEdge *fe);
 
        real occluderProscenium[4];
        real gridSpaceOccluderProscenium[4];
@@ -60,4 +66,4 @@ private:
        bool gridSpaceOccluderProsceniumInitialized;
 };
 
-#endif // CULLEDOCCLUDERSOURCE_H
+#endif // __FREESTYLE_CULLED_OCCLUDER_SOURCE_H__
index 1d52f37236ef871801d785e0910854053a2cb459..9631c93cd7e6f9aea23a2087065f60acaca7bb5e 100644 (file)
-
-//
-//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
-//   with this source distribution. 
-//
-//  This program is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU General Public License
-//  as published by the Free Software Foundation; either version 2
-//  of the License, or (at your option) any later version.
-//
-//  This program is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//  GNU General Public License for more details.
-//
-//  You should have received a copy of the GNU General Public License
-//  along with this program; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
-//
-///////////////////////////////////////////////////////////////////////////////
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) 2010 Blender Foundation.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file blender/freestyle/intern/view_map/FEdgeXDetector.cpp
+ *  \ingroup freestyle
+ *  \brief Detects/flags/builds extended features edges on the WXEdge structure
+ *  \author Stephane Grabli
+ *  \date 26/10/2003
+ */
+
+#include <float.h>
+#include <math.h>
 
 #include "FEdgeXDetector.h"
-#include "float.h"
+
 #include "../geometry/GeomUtils.h"
-#include <math.h>
 #include "../geometry/normal_cycle.h"
 
-void FEdgeXDetector::processShapes(WingedEdge& we) {
-  bool progressBarDisplay = false;
-  Vec3r Min, Max;
-  vector<WShape*> wshapes = we.getWShapes();
-  WXShape * wxs;
-
-  if(_pProgressBar != NULL) {
-    _pProgressBar->reset();
-    _pProgressBar->setLabelText("Detecting feature lines");
-    _pProgressBar->setTotalSteps(wshapes.size() * 3);
-    _pProgressBar->setProgress(0);
-    progressBarDisplay = true;
-  }
-
-  for(vector<WShape*>::const_iterator it = wshapes.begin();
-  it != wshapes.end();
-  it++){
-    if (_pRenderMonitor && _pRenderMonitor->testBreak())
-      break;
-    wxs = dynamic_cast<WXShape*>(*it);
-    wxs->bbox(Min, Max);
-    _bbox_diagonal = (Max-Min).norm();
-    if(_changes){
-      vector<WFace*>& wfaces = wxs->GetFaceList();
-      for(vector<WFace*>::iterator wf=wfaces.begin(), wfend=wfaces.end();
-      wf!=wfend;
-      ++wf){
-        WXFace* wxf = dynamic_cast<WXFace*>(*wf);
-        wxf->Clear();
-      }
-      _computeViewIndependant = true;
-    } else if (!(wxs)->getComputeViewIndependantFlag()) {
-      wxs->Reset();
-      _computeViewIndependant = false;
-    } else {
-      _computeViewIndependant = true;
-    }
-    preProcessShape(wxs);
-    if (progressBarDisplay)
-      _pProgressBar->setProgress(_pProgressBar->getProgress() + 1);
-    processBorderShape(wxs);
-    if(_computeMaterialBoundaries)
-      processMaterialBoundaryShape(wxs);
-    processCreaseShape(wxs);
-    if(_computeRidgesAndValleys)
-      processRidgesAndValleysShape(wxs);
-    if(_computeSuggestiveContours)
-      processSuggestiveContourShape(wxs);
-    processSilhouetteShape(wxs);
-    processEdgeMarksShape(wxs);
-    if (progressBarDisplay)
-      _pProgressBar->setProgress(_pProgressBar->getProgress() + 1);
-
-    // build smooth edges:
-    buildSmoothEdges(wxs);
-
-    // Post processing for suggestive contours
-    if(_computeSuggestiveContours)
-      postProcessSuggestiveContourShape(wxs);
-    if (progressBarDisplay)
-      _pProgressBar->setProgress(_pProgressBar->getProgress() + 1);
-
-    wxs->setComputeViewIndependantFlag(false);
-    _computeViewIndependant = false;
-    _changes = false;
-
-    // reset user data
-    (*it)->ResetUserData();
-  }
+void FEdgeXDetector::processShapes(WingedEdge& we)
+{
+       bool progressBarDisplay = false;
+       Vec3r Min, Max;
+       vector<WShape*> wshapes = we.getWShapes();
+       WXShape *wxs;
+
+       if (_pProgressBar != NULL) {
+               _pProgressBar->reset();
+               _pProgressBar->setLabelText("Detecting feature lines");
+               _pProgressBar->setTotalSteps(wshapes.size() * 3);
+               _pProgressBar->setProgress(0);
+               progressBarDisplay = true;
+       }
+
+       for (vector<WShape*>::const_iterator it = wshapes.begin(); it != wshapes.end(); it++) {
+               if (_pRenderMonitor && _pRenderMonitor->testBreak())
+                       break;
+               wxs = dynamic_cast<WXShape*>(*it);
+               wxs->bbox(Min, Max);
+               _bbox_diagonal = (Max - Min).norm();
+               if (_changes) {
+                       vector<WFace*>& wfaces = wxs->GetFaceList();
+                       for (vector<WFace*>::iterator wf = wfaces.begin(), wfend = wfaces.end(); wf != wfend; ++wf) {
+                               WXFace *wxf = dynamic_cast<WXFace*>(*wf);
+                               wxf->Clear();
+                       }
+                       _computeViewIndependant = true;
+               }
+               else if (!(wxs)->getComputeViewIndependantFlag()) {
+                       wxs->Reset();
+                       _computeViewIndependant = false;
+               }
+               else {
+                       _computeViewIndependant = true;
+               }
+               preProcessShape(wxs);
+               if (progressBarDisplay)
+                       _pProgressBar->setProgress(_pProgressBar->getProgress() + 1);
+               processBorderShape(wxs);
+               if (_computeMaterialBoundaries)
+                       processMaterialBoundaryShape(wxs);
+               processCreaseShape(wxs);
+               if (_computeRidgesAndValleys)
+                       processRidgesAndValleysShape(wxs);
+               if (_computeSuggestiveContours)
+                       processSuggestiveContourShape(wxs);
+               processSilhouetteShape(wxs);
+               processEdgeMarksShape(wxs);
+               if (progressBarDisplay)
+                       _pProgressBar->setProgress(_pProgressBar->getProgress() + 1);
+
+               // build smooth edges:
+               buildSmoothEdges(wxs);
+
+               // Post processing for suggestive contours
+               if (_computeSuggestiveContours)
+                       postProcessSuggestiveContourShape(wxs);
+               if (progressBarDisplay)
+                       _pProgressBar->setProgress(_pProgressBar->getProgress() + 1);
+
+               wxs->setComputeViewIndependantFlag(false);
+               _computeViewIndependant = false;
+               _changes = false;
+
+               // reset user data
+               (*it)->ResetUserData();
+       }
 }
 
 // GENERAL STUFF
 ////////////////
-void FEdgeXDetector::preProcessShape(WXShape* iWShape) {
-  _meanK1 = 0;
-  _meanKr = 0;
-  _minK1 = FLT_MAX;
-  _maxK1 = -FLT_MAX;
-  _minKr = FLT_MAX;
-  _maxKr = -FLT_MAX;
-  _nPoints = 0;
-  _meanEdgeSize = iWShape->getMeanEdgeSize();
-  
-  vector<WFace*>& wfaces = iWShape->GetFaceList();
-  vector<WFace*>::iterator f,fend;
-  // view dependant stuff
-  for(f=wfaces.begin(), fend=wfaces.end();
-  f!=fend;
-  ++f){
-    preProcessFace((WXFace*)(*f));
-  }
-
-  if(_computeRidgesAndValleys || _computeSuggestiveContours ) {
-    vector<WVertex*>& wvertices = iWShape->getVertexList();
-    for(vector<WVertex*>::iterator wv=wvertices.begin(), wvend=wvertices.end(); 
-    wv!=wvend;
-    ++wv){
-      // Compute curvatures
-      WXVertex * wxv = dynamic_cast<WXVertex*>(*wv);
-      computeCurvatures(wxv);
-    }
-    _meanK1 /= (real)(_nPoints);
-    _meanKr /= (real)(_nPoints);
-  }
+void FEdgeXDetector::preProcessShape(WXShape *iWShape)
+{
+       _meanK1 = 0;
+       _meanKr = 0;
+       _minK1 = FLT_MAX;
+       _maxK1 = -FLT_MAX;
+       _minKr = FLT_MAX;
+       _maxKr = -FLT_MAX;
+       _nPoints = 0;
+       _meanEdgeSize = iWShape->getMeanEdgeSize();
+
+       vector<WFace*>& wfaces = iWShape->GetFaceList();
+       vector<WFace*>::iterator f, fend;
+       // view dependant stuff
+       for (f = wfaces.begin(), fend = wfaces.end(); f != fend; ++f) {
+               preProcessFace((WXFace*)(*f));
+       }
+
+       if (_computeRidgesAndValleys || _computeSuggestiveContours) {
+               vector<WVertex*>& wvertices = iWShape->getVertexList();
+               for (vector<WVertex*>::iterator wv = wvertices.begin(), wvend = wvertices.end();  wv != wvend; ++wv) {
+                       // Compute curvatures
+                       WXVertex *wxv = dynamic_cast<WXVertex*>(*wv);
+                       computeCurvatures(wxv);
+               }
+               _meanK1 /= (real)(_nPoints);
+               _meanKr /= (real)(_nPoints);
+       }
 }
 
-void FEdgeXDetector::preProcessFace(WXFace *iFace){
-  Vec3r firstPoint = iFace->GetVertex(0)->GetVertex();
-  Vec3r N = iFace->GetNormal();
-
-  // Compute the dot product between V (=_Viewpoint - firstPoint) and N:
-  Vec3r V;
-  if (_orthographicProjection) {
-    V = Vec3r(0.0, 0.0, _Viewpoint.z() - firstPoint.z());
-  } else {
-    V = Vec3r(_Viewpoint - firstPoint);
-  }
-  N.normalize();
-  V.normalize();
-  iFace->setDotP(N * V);
-  
-  // compute the distance between the face center and the viewpoint:
-  if (_orthographicProjection) {
-    iFace->setZ(iFace->center().z() - _Viewpoint.z());
-  } else {
-    Vec3r dist_vec(iFace->center() - _Viewpoint);
-    iFace->setZ(dist_vec.norm());
-  }
+void FEdgeXDetector::preProcessFace(WXFace *iFace)
+{
+       Vec3r firstPoint = iFace->GetVertex(0)->GetVertex();
+       Vec3r N = iFace->GetNormal();
+
+       // Compute the dot product between V (=_Viewpoint - firstPoint) and N:
+       Vec3r V;
+       if (_orthographicProjection) {
+               V = Vec3r(0.0, 0.0, _Viewpoint.z() - firstPoint.z());
+       }
+       else {
+               V = Vec3r(_Viewpoint - firstPoint);
+       }
+       N.normalize();
+       V.normalize();
+       iFace->setDotP(N * V);
+
+       // compute the distance between the face center and the viewpoint:
+       if (_orthographicProjection) {
+               iFace->setZ(iFace->center().z() - _Viewpoint.z());
+       }
+       else {
+               Vec3r dist_vec(iFace->center() - _Viewpoint);
+               iFace->setZ(dist_vec.norm());
+       }
 }
 
-void FEdgeXDetector::computeCurvatures(WXVertex *vertex){
-   // CURVATURE LAYER
-  // store all the curvature datas for each vertex
-
-  //soc unused - real K1, K2
-  real cos2theta, sin2theta;
-  Vec3r e1, n, v;
-  // one vertex curvature info :
-  CurvatureInfo *C;
-  float radius = _sphereRadius*_meanEdgeSize; 
-  
-  // view independant stuff
-  if(_computeViewIndependant){
-    C = new CurvatureInfo();   
-    vertex->setCurvatures(C);
-    OGF::NormalCycle ncycle ;
-    ncycle.begin() ;
-    if(radius > 0) {
-      OGF::compute_curvature_tensor(vertex, radius, ncycle) ;
-    } else {
-      OGF::compute_curvature_tensor_one_ring(vertex, ncycle) ;
-    }
-    ncycle.end() ;
-    C->K1 = ncycle.kmin();
-    C->K2 = ncycle.kmax();
-    C->e1 = ncycle.Kmax(); //ncycle.kmin() * ncycle.Kmax();
-    C->e2 = ncycle.Kmin(); //ncycle.kmax() * ncycle.Kmin() ;
-
-    real absK1 = fabs(C->K1);
-    _meanK1 += absK1;
-    if(absK1 > _maxK1)
-      _maxK1 = absK1;
-    if(absK1 < _minK1)
-      _minK1 = absK1;
-  }
-  // view dependant
-  C = vertex->curvatures();
-  if(C == 0)
-    return;
-    
-  // compute radial curvature :
-  n = C->e1 ^ C->e2;
-  if (_orthographicProjection) {
-    v = Vec3r(0.0, 0.0, _Viewpoint.z() - vertex->GetVertex().z());
-  } else {
-    v = Vec3r(_Viewpoint - vertex->GetVertex());
-  }
-  C->er = v - (v * n) * n;
-  C->er.normalize();
-  e1 = C->e1;
-  e1.normalize();
-  cos2theta = C->er * e1;
-  cos2theta *= cos2theta;
-  sin2theta = 1 - cos2theta;
-  C->Kr = C->K1 * cos2theta + C->K2 * sin2theta;
-  real absKr = fabs(C->Kr);
-  _meanKr += absKr;
-  if(absKr > _maxKr)
-    _maxKr = absKr;
-  if(absKr < _minKr)
-    _minKr = absKr;
-
-  ++_nPoints;
+void FEdgeXDetector::computeCurvatures(WXVertex *vertex)
+{
+       // CURVATURE LAYER
+       // store all the curvature datas for each vertex
+
+       //soc unused - real K1, K2
+       real cos2theta, sin2theta;
+       Vec3r e1, n, v;
+       // one vertex curvature info :
+       CurvatureInfo *C;
+       float radius = _sphereRadius * _meanEdgeSize; 
+
+       // view independant stuff
+       if (_computeViewIndependant) {
+               C = new CurvatureInfo();
+               vertex->setCurvatures(C);
+               OGF::NormalCycle ncycle;
+               ncycle.begin();
+               if (radius > 0) {
+                       OGF::compute_curvature_tensor(vertex, radius, ncycle);
+               }
+               else {
+                       OGF::compute_curvature_tensor_one_ring(vertex, ncycle);
+               }
+               ncycle.end();
+               C->K1 = ncycle.kmin();
+               C->K2 = ncycle.kmax();
+               C->e1 = ncycle.Kmax(); //ncycle.kmin() * ncycle.Kmax();
+               C->e2 = ncycle.Kmin(); //ncycle.kmax() * ncycle.Kmin();
+
+               real absK1 = fabs(C->K1);
+               _meanK1 += absK1;
+               if (absK1 > _maxK1)
+                       _maxK1 = absK1;
+               if (absK1 < _minK1)
+                       _minK1 = absK1;
+       }
+       // view dependant
+       C = vertex->curvatures();
+       if (C == 0)
+               return;
+
+       // compute radial curvature :
+       n = C->e1 ^ C->e2;
+       if (_orthographicProjection) {
+               v = Vec3r(0.0, 0.0, _Viewpoint.z() - vertex->GetVertex().z());
+       }
+       else {
+               v = Vec3r(_Viewpoint - vertex->GetVertex());
+       }
+       C->er = v - (v * n) * n;
+       C->er.normalize();
+       e1 = C->e1;
+       e1.normalize();
+       cos2theta = C->er * e1;
+       cos2theta *= cos2theta;
+       sin2theta = 1 - cos2theta;
+       C->Kr = C->K1 * cos2theta + C->K2 * sin2theta;
+       real absKr = fabs(C->Kr);
+       _meanKr += absKr;
+       if (absKr > _maxKr)
+               _maxKr = absKr;
+       if (absKr < _minKr)
+               _minKr = absKr;
+
+       ++_nPoints;
 }
 
 // SILHOUETTE
 /////////////
-void FEdgeXDetector::processSilhouetteShape(WXShape* iWShape) {
-  // Make a first pass on every polygons in order 
-  // to compute all their silhouette relative values:
-  //------------------------------------------------
-  vector<WFace*>& wfaces = iWShape->GetFaceList();
-  vector<WFace*>::iterator f,fend;
-  for(f=wfaces.begin(), fend=wfaces.end();
-  f!=fend;
-  ++f)
-  {
-    ProcessSilhouetteFace((WXFace*)(*f));
-  }
-
-  // Make a pass on the edges to detect 
-  // the silhouette edges that are not smooth
-  // --------------------
-  vector<WEdge*>::iterator we, weend;
-  vector<WEdge*> &wedges = iWShape->getEdgeList();
-  for(we=wedges.begin(), weend=wedges.end();
-  we!=weend;
-  ++we)
-  {
-    ProcessSilhouetteEdge((WXEdge*)(*we));
-  }
+void FEdgeXDetector::processSilhouetteShape(WXShape *iWShape)
+{
+       // Make a first pass on every polygons in order to compute all their silhouette relative values:
+       vector<WFace*>& wfaces = iWShape->GetFaceList();
+       vector<WFace*>::iterator f, fend;
+       for (f = wfaces.begin(), fend = wfaces.end(); f != fend; ++f) {
+               ProcessSilhouetteFace((WXFace*)(*f));
+       }
+
+       // Make a pass on the edges to detect the silhouette edges that are not smooth
+       vector<WEdge*>::iterator we, weend;
+       vector<WEdge*> &wedges = iWShape->getEdgeList();
+       for (we = wedges.begin(), weend = wedges.end(); we != weend; ++we) {
+               ProcessSilhouetteEdge((WXEdge*)(*we));
+       }
 }
 
 void FEdgeXDetector::ProcessSilhouetteFace(WXFace *iFace)
 {
-  
-  // SILHOUETTE LAYER
-  Vec3r normal;
-  // Compute the dot products between View direction and N at each vertex
-  // of the face:
-  Vec3r point;
-  int closestPointId = 0;
-  real dist, minDist = FLT_MAX;
-  int numVertices = iFace->numberOfVertices();
-  WXFaceLayer * faceLayer = new WXFaceLayer(iFace, Nature::SILHOUETTE, true);
-  for(int i=0; i<numVertices; i++){
-    point = iFace->GetVertex(i)->GetVertex();
-    normal = iFace->GetVertexNormal(i);
-    normal.normalize();
-    Vec3r V;
-    if (_orthographicProjection) {
-      V = Vec3r(0.0, 0.0, _Viewpoint.z() - point.z());
-    } else {
-      V = Vec3r(_Viewpoint - point);
-    }
-    V.normalize();
-    real d = normal * V;
-    faceLayer->PushDotP(d);
-    // Find the point the closest to the viewpoint
-    if (_orthographicProjection) {
-      dist = point.z() - _Viewpoint.z();
-    } else {
-      Vec3r dist_vec(point - _Viewpoint);
-      dist = dist_vec.norm();
-    }
-    if(dist < minDist) {
-      minDist = dist;
-      closestPointId = i;
-    }
-  }
-  // Set the closest point id:
-  faceLayer->setClosestPointIndex(closestPointId);
-  // Add this layer to the face:
-  iFace->AddSmoothLayer(faceLayer);
+       // SILHOUETTE LAYER
+       Vec3r normal;
+       // Compute the dot products between View direction and N at each vertex of the face:
+       Vec3r point;
+       int closestPointId = 0;
+       real dist, minDist = FLT_MAX;
+       int numVertices = iFace->numberOfVertices();
+       WXFaceLayer *faceLayer = new WXFaceLayer(iFace, Nature::SILHOUETTE, true);
+       for (int i = 0; i < numVertices; i++) {
+               point = iFace->GetVertex(i)->GetVertex();
+               normal = iFace->GetVertexNormal(i);
+               normal.normalize();
+               Vec3r V;
+               if (_orthographicProjection) {
+                       V = Vec3r(0.0, 0.0, _Viewpoint.z() - point.z());
+               }
+               else {
+                       V = Vec3r(_Viewpoint - point);
+               }
+               V.normalize();
+               real d = normal * V;
+               faceLayer->PushDotP(d);
+               // Find the point the closest to the viewpoint
+               if (_orthographicProjection) {
+                       dist = point.z() - _Viewpoint.z();
+               }
+               else {
+                       Vec3r dist_vec(point - _Viewpoint);
+                       dist = dist_vec.norm();
+               }
+               if (dist < minDist) {
+                       minDist = dist;
+                       closestPointId = i;
+               }
+       }
+       // Set the closest point id:
+       faceLayer->setClosestPointIndex(closestPointId);
+       // Add this layer to the face:
+       iFace->AddSmoothLayer(faceLayer);
 }
 
 void FEdgeXDetector::ProcessSilhouetteEdge(WXEdge *iEdge)
 {
-  if(iEdge->nature() & Nature::BORDER)
-    return;
-  // SILHOUETTE ?
-  //-------------
-  WXFace * fA = (WXFace *)iEdge->GetaOEdge()->GetaFace();
-  WXFace * fB = (WXFace *)iEdge->GetaOEdge()->GetbFace();
-
-  if((fA->front())^(fB->front())){ // fA->visible XOR fB->visible (true if one is 0 and the other is 1)
-    // The only edges we want to set as silhouette edges in this 
-    // way are the ones with 2 different normals for 1 vertex 
-    // for these two faces
-    //--------------------
-    // In reality we only test the normals for 1 of the 2 vertices.
-    if(fA->GetVertexNormal(iEdge->GetaVertex()) == fB->GetVertexNormal(iEdge->GetaVertex()))
-      return;
-    iEdge->AddNature(Nature::SILHOUETTE);
-    if(fB->front())
-      iEdge->setOrder(1);
-    else
-      iEdge->setOrder(-1);
-  }
+       if (iEdge->nature() & Nature::BORDER)
+               return;
+       // SILHOUETTE ?
+       //-------------
+       WXFace *fA = (WXFace *)iEdge->GetaOEdge()->GetaFace();
+       WXFace *fB = (WXFace *)iEdge->GetaOEdge()->GetbFace();
+
+       if ((fA->front()) ^ (fB->front())) { // fA->visible XOR fB->visible (true if one is 0 and the other is 1)
+               // The only edges we want to set as silhouette edges in this way are the ones with 2 different normals for 1 vertex
+               // for these two faces
+               //--------------------
+               // In reality we only test the normals for 1 of the 2 vertices.
+               if (fA->GetVertexNormal(iEdge->GetaVertex()) == fB->GetVertexNormal(iEdge->GetaVertex()))
+                       return;
+               iEdge->AddNature(Nature::SILHOUETTE);
+               if (fB->front())
+                       iEdge->setOrder(1);
+               else
+                       iEdge->setOrder(-1);
+       }
 }
 
-
 // BORDER
 /////////
-void FEdgeXDetector::processBorderShape(WXShape* iWShape) {
-
-  if(!_computeViewIndependant)
-    return;
-  // Make a pass on the edges to detect 
-  // the BORDER
-  // --------------------
-  vector<WEdge*>::iterator we, weend;
-  vector<WEdge*> &wedges = iWShape->getEdgeList();
-  for(we=wedges.begin(), weend=wedges.end();
-  we!=weend;
-  ++we){
-    ProcessBorderEdge((WXEdge*)(*we));
-  }
+void FEdgeXDetector::processBorderShape(WXShape *iWShape)
+{
+       if (!_computeViewIndependant)
+               return;
+       // Make a pass on the edges to detect the BORDER
+       vector<WEdge*>::iterator we, weend;
+       vector<WEdge*> &wedges = iWShape->getEdgeList();
+       for (we = wedges.begin(), weend = wedges.end(); we != weend; ++we) {
+               ProcessBorderEdge((WXEdge *)(*we));
+       }
 }
 
 void FEdgeXDetector::ProcessBorderEdge(WXEdge *iEdge)
 {
-  // first check whether it is a border edge:
-  // BORDER ?
-  //---------
-  if(iEdge->GetaFace() == 0){
-    // it is a border edge
-    iEdge->AddNature(Nature::BORDER);
-  }
+       // first check whether it is a border edge: BORDER ?
+       //---------
+       if (iEdge->GetaFace() == 0) {
+               // it is a border edge
+               iEdge->AddNature(Nature::BORDER);
+       }
 }
 
 
 // CREASE
 /////////
-void FEdgeXDetector::processCreaseShape(WXShape* iWShape) {
-  if(!_computeViewIndependant)
-    return;
-
-  // Make a pass on the edges to detect 
-  // the CREASE 
-  // --------------------
-  vector<WEdge*>::iterator we, weend;
-  vector<WEdge*> &wedges = iWShape->getEdgeList();
-  for(we=wedges.begin(), weend=wedges.end();
-  we!=weend;
-  ++we){
-    ProcessCreaseEdge((WXEdge*)(*we));
-  }
+void FEdgeXDetector::processCreaseShape(WXShape *iWShape)
+{
+       if (!_computeViewIndependant)
+               return;
+
+       // Make a pass on the edges to detect the CREASE 
+       vector<WEdge*>::iterator we, weend;
+       vector<WEdge*> &wedges = iWShape->getEdgeList();
+       for (we = wedges.begin(), weend = wedges.end(); we != weend; ++we) {
+               ProcessCreaseEdge((WXEdge *)(*we));
+       }
 }
 
 void FEdgeXDetector::ProcessCreaseEdge(WXEdge *iEdge)
 {
-  // CREASE ?
-  //---------
-  if(iEdge->nature() & Nature::BORDER)
-    return;
-  WXFace * fA = (WXFace *)iEdge->GetaOEdge()->GetaFace();
-  WXFace * fB = (WXFace *)iEdge->GetaOEdge()->GetbFace();
-
-  WVertex * aVertex = iEdge->GetaVertex();
-  if((fA->GetVertexNormal(aVertex) * fB->GetVertexNormal(aVertex)) <= _creaseAngle)
-    iEdge->AddNature(Nature::CREASE);
+       // CREASE ?
+       //---------
+       if (iEdge->nature() & Nature::BORDER)
+               return;
+       WXFace *fA = (WXFace *)iEdge->GetaOEdge()->GetaFace();
+       WXFace *fB = (WXFace *)iEdge->GetaOEdge()->GetbFace();
+
+       WVertex *aVertex = iEdge->GetaVertex();
+       if ((fA->GetVertexNormal(aVertex) * fB->GetVertexNormal(aVertex)) <= _creaseAngle)
+               iEdge->AddNature(Nature::CREASE);
 }
 
 // RIDGES AND VALLEYS
 /////////////////////
+void FEdgeXDetector::processRidgesAndValleysShape(WXShape *iWShape)
+{
+       // Don't forget to add the built layer to the face at the end of the ProcessFace:
+       //iFace->AddSmoothLayer(faceLayer);
 
-void FEdgeXDetector::processRidgesAndValleysShape(WXShape* iWShape) {
-  // Don't forget to add the built layer to the face at the end
-  // of the ProcessFace:
-  //iFace->AddSmoothLayer(faceLayer);
-
-  if((!_computeViewIndependant))
-    return;
-  
-  // Here the curvatures must already have been computed
-  vector<WFace*>& wfaces = iWShape->GetFaceList();
-  vector<WFace*>::iterator f, fend;
-  for(f=wfaces.begin(), fend=wfaces.end();
-       f!=fend;
-       ++f)
-  { 
-       ProcessRidgeFace((WXFace*)(*f));
-  }
+       if (!_computeViewIndependant)
+               return;
+
+       // Here the curvatures must already have been computed
+       vector<WFace*>& wfaces = iWShape->GetFaceList();
+       vector<WFace*>::iterator f, fend;
+       for (f = wfaces.begin(), fend = wfaces.end(); f != fend; ++f) {
+               ProcessRidgeFace((WXFace*)(*f));
+       }
 }
 
 
 // RIDGES
 /////////
-
 void FEdgeXDetector::ProcessRidgeFace(WXFace *iFace)
 {
-  WXFaceLayer * flayer = new WXFaceLayer(iFace, Nature::RIDGE|Nature::VALLEY, false);
-  iFace->AddSmoothLayer(flayer);
-  
-  unsigned int numVertices = iFace->numberOfVertices();
-  for(unsigned int i=0; i<numVertices; ++i){
-    WVertex *wv = iFace->GetVertex(i);
-    WXVertex * wxv = dynamic_cast<WXVertex*>(wv);
-    flayer->PushDotP(wxv->curvatures()->K1);
-  }
-
-  real threshold = 0;
-  //real threshold = _maxK1 - (_maxK1-_meanK1)/20.0;
-  
-  if(flayer->nPosDotP()!=numVertices){
-    if((fabs(flayer->dotP(0)) < threshold) && (fabs(flayer->dotP(1)) < threshold) && (fabs(flayer->dotP(2)) < threshold)){
-      flayer->ReplaceDotP(0, 0);
-      flayer->ReplaceDotP(1, 0);
-      flayer->ReplaceDotP(2, 0);
-    }
-  }
+       WXFaceLayer *flayer = new WXFaceLayer(iFace, Nature::RIDGE|Nature::VALLEY, false);
+       iFace->AddSmoothLayer(flayer);
+
+       unsigned int numVertices = iFace->numberOfVertices();
+       for (unsigned int i = 0; i < numVertices; ++i) {
+               WVertex *wv = iFace->GetVertex(i);
+               WXVertex *wxv = dynamic_cast<WXVertex*>(wv);
+               flayer->PushDotP(wxv->curvatures()->K1);
+       }
+
+       real threshold = 0;
+       //real threshold = _maxK1 - (_maxK1 - _meanK1) / 20.0;
+
+       if (flayer->nPosDotP() != numVertices) {
+               if ((fabs(flayer->dotP(0)) < threshold) && (fabs(flayer->dotP(1)) < threshold) &&
+                   (fabs(flayer->dotP(2)) < threshold))
+               {
+                       flayer->ReplaceDotP(0, 0);
+                       flayer->ReplaceDotP(1, 0);
+                       flayer->ReplaceDotP(2, 0);
+               }
+       }
 }
 
-// void FEdgeXDetector::ProcessRidgeFace(WXFace *iFace)
-// {
-//  //  RIDGE LAYER
-//  //    compute the RidgeFunction, that is the derivative of the ppal curvature
-//  //    along e1 at each vertex of the face
-//  WVertex *v;
-//  Vec3r v1v2;
-//  real t;
-//  vector<WXFaceLayer*> SmoothLayers;
-//  WXFaceLayer *faceLayer;
-//  Face_Curvature_Info *layer_info;
-//  real K1_a(0), K1_b(0);
-//  Vec3r Inter_a, Inter_b;
-
-//  //  find the ridge layer of the face
-//  iFace->retrieveSmoothLayers(Nature::RIDGE, SmoothLayers);
-//  if(SmoothLayers.size()!=1)
-//    return;
-//  faceLayer = SmoothLayers[0];
-//  //  retrieve the curvature info of this layer
-//  layer_info = (Face_Curvature_Info *)faceLayer->userdata;
-//  int numVertices = iFace->numberOfVertices();
-//  for(int i=0; i<numVertices; i++){
-//    v = iFace->GetVertex(i);
-//    //    vec_curvature_info[i] contains the curvature info of this vertex
-//    Vec3r e2 = layer_info->vec_curvature_info[i]->K2*layer_info->vec_curvature_info[i]->e2;
-//    Vec3r e1 = layer_info->vec_curvature_info[i]->K1*layer_info->vec_curvature_info[i]->e1;
-//    e2.normalize();
-   
-//    WVertex::face_iterator fit = v->faces_begin();
-//    WVertex::face_iterator fitend = v->faces_end();
-//    for(; fit!=fitend; ++fit){  
-//      WXFace * wxf = dynamic_cast<WXFace*>(*fit);
-//      WOEdge * oppositeEdge;
-//      if(!(wxf->getOppositeEdge(v, oppositeEdge)))
-//        continue;
-//      v1v2 = oppositeEdge->GetbVertex()->GetVertex() - oppositeEdge->GetaVertex()->GetVertex();
-//      GeomUtils::intersection_test res;
-//      res = GeomUtils::intersectRayPlane(oppositeEdge->GetaVertex()->GetVertex(), v1v2,
-//        e2, -(v->GetVertex()*e2),
-//        t,1.e-06);
-//      if((res == GeomUtils::DO_INTERSECT) && (t>=0.0) && (t<=1.0)){
-//        vector<WXFaceLayer*> second_ridge_layer;
-//        wxf->retrieveSmoothLayers(Nature::RIDGE, second_ridge_layer);
-//        if(second_ridge_layer.size()!=1)
-//          continue;
-//        Face_Curvature_Info *second_layer_info = (Face_Curvature_Info*)second_ridge_layer[0]->userdata;
-       
-//        unsigned index1 = wxf->GetIndex(oppositeEdge->GetaVertex());
-//        unsigned index2 = wxf->GetIndex(oppositeEdge->GetbVertex());
-//        real K1_1 = second_layer_info->vec_curvature_info[index1]->K1;
-//        real K1_2 = second_layer_info->vec_curvature_info[index2]->K1;
-//        real K1 = (1.0-t)*K1_1 + t*K1_2;
-//        Vec3r inter((1.0-t)*oppositeEdge->GetaVertex()->GetVertex() + t*oppositeEdge->GetbVertex()->GetVertex());
-//        Vec3r vtmp(inter - v->GetVertex());
-//        // is it K1_a or K1_b ?
-//        if(vtmp*e1 > 0){
-//          K1_b = K1;
-//          Inter_b = inter;
-//        }else{
-//          K1_a = K1;
-//          Inter_a = inter;
-//        }
-//      }  
-//    }  
-//    //    Once we have K1 along the the ppal direction
-//    //      compute the derivative : K1b - K1a
-//    //      put it in DotP
-//    //real d = fabs(K1_b)-fabs(K1_a);
-//    real d = 0;
-//    real threshold = _meanK1 + (_maxK1-_meanK1)/7.0;
-//    //real threshold = _meanK1;
-//    //if((fabs(K1_b) > threshold) || ((fabs(K1_a) > threshold)))
-//      d = (K1_b)-(K1_a)/(Inter_b-Inter_a).norm();
-//    faceLayer->PushDotP(d);
-//    //faceLayer->PushDotP(layer_info->vec_curvature_info[i]->K1);
-//  } 
-
-//  // Make the values relevant by checking whether all principal 
-//  // directions have the "same" direction:
-//  Vec3r e0((layer_info->vec_curvature_info[0]->K1*layer_info->vec_curvature_info[0]->e1));
-//  e0.normalize();
-//  Vec3r e1((layer_info->vec_curvature_info[1]->K1*layer_info->vec_curvature_info[1]->e1));
-//  e1.normalize();
-//  Vec3r e2((layer_info->vec_curvature_info[2]->K1*layer_info->vec_curvature_info[2]->e1));
-//  e2.normalize();
-//  if (e0 * e1 < 0)
-//    // invert dotP[1]
-//    faceLayer->ReplaceDotP(1, -faceLayer->dotP(1));
-//  if (e0 * e2 < 0)
-//    // invert dotP[2]
-//    faceLayer->ReplaceDotP(2, -faceLayer->dotP(2));
-
-//  // remove the weakest values;
-//  //real minDiff = (_maxK1 - _minK1)/10.0;
-//  //  real minDiff = _meanK1;
-//  //  if((faceLayer->dotP(0) < minDiff) && (faceLayer->dotP(1) < minDiff) && (faceLayer->dotP(2) < minDiff)){
-//  //    faceLayer->ReplaceDotP(0, 0);
-//  //    faceLayer->ReplaceDotP(1, 0);
-//  //    faceLayer->ReplaceDotP(2, 0);
-//  //  } 
-// }
+#if 0
+void FEdgeXDetector::ProcessRidgeFace(WXFace *iFace)
+{
+       // RIDGE LAYER
+       // Compute the RidgeFunction, that is the derivative of the ppal curvature along e1 at each vertex of the face
+       WVertex *v;
+       Vec3r v1v2;
+       real t;
+       vector<WXFaceLayer*> SmoothLayers;
+       WXFaceLayer *faceLayer;
+       Face_Curvature_Info *layer_info;
+       real K1_a(0), K1_b(0);
+       Vec3r Inter_a, Inter_b;
+
+       // find the ridge layer of the face
+       iFace->retrieveSmoothLayers(Nature::RIDGE, SmoothLayers);
+       if ( SmoothLayers.size()!=1 )
+               return;
+       faceLayer = SmoothLayers[0];
+       // retrieve the curvature info of this layer
+       layer_info = (Face_Curvature_Info *)faceLayer->userdata;
+
+       int numVertices = iFace->numberOfVertices();
+       for (int i = 0; i < numVertices; i++) {
+               v = iFace->GetVertex(i);
+               // vec_curvature_info[i] contains the curvature info of this vertex
+               Vec3r e2 = layer_info->vec_curvature_info[i]->K2*layer_info->vec_curvature_info[i]->e2;
+               Vec3r e1 = layer_info->vec_curvature_info[i]->K1*layer_info->vec_curvature_info[i]->e1;
+               e2.normalize();
+
+               WVertex::face_iterator fit = v->faces_begin();
+               WVertex::face_iterator fitend = v->faces_end();
+               for (; fit != fitend; ++fit) {
+                       WXFace *wxf = dynamic_cast<WXFace*>(*fit);
+                       WOEdge *oppositeEdge;
+                       if (!(wxf->getOppositeEdge(v, oppositeEdge)))
+                               continue;
+                       v1v2 = oppositeEdge->GetbVertex()->GetVertex() - oppositeEdge->GetaVertex()->GetVertex();
+                       GeomUtils::intersection_test res;
+                       res = GeomUtils::intersectRayPlane(oppositeEdge->GetaVertex()->GetVertex(), v1v2, e2, -(v->GetVertex()*e2),
+                                                          t, 1.0e-06);
+                       if ((res == GeomUtils::DO_INTERSECT) && (t >= 0.0) && (t <= 1.0)) {
+                               vector<WXFaceLayer*> second_ridge_layer;
+                               wxf->retrieveSmoothLayers(Nature::RIDGE, second_ridge_layer);
+                               if (second_ridge_layer.size() != 1)
+                                       continue;
+                               Face_Curvature_Info *second_layer_info = (Face_Curvature_Info*)second_ridge_layer[0]->userdata;
+
+                               unsigned index1 = wxf->GetIndex(oppositeEdge->GetaVertex());
+                               unsigned index2 = wxf->GetIndex(oppositeEdge->GetbVertex());
+                               real K1_1 = second_layer_info->vec_curvature_info[index1]->K1;
+                               real K1_2 = second_layer_info->vec_curvature_info[index2]->K1;
+                               real K1 = (1.0 - t) * K1_1 + t * K1_2;
+                               Vec3r inter((1.0 - t) * oppositeEdge->GetaVertex()->GetVertex() +
+                                           t * oppositeEdge->GetbVertex()->GetVertex());
+                               Vec3r vtmp(inter - v->GetVertex());
+                               // is it K1_a or K1_b ?
+                               if (vtmp * e1 > 0) {
+                                       K1_b = K1;
+                                       Inter_b = inter;
+                               }
+                               else {
+                                       K1_a = K1;
+                                       Inter_a = inter;
+                               }
+                       }
+               }
+               // Once we have K1 along the the ppal direction compute the derivative : K1b - K1a put it in DotP
+               //real d = fabs(K1_b) - fabs(K1_a);
+               real d = 0;
+               real threshold = _meanK1 + (_maxK1 - _meanK1) / 7.0;
+               //real threshold = _meanK1;
+               //if ((fabs(K1_b) > threshold) || ((fabs(K1_a) > threshold)))
+               d = (K1_b) - (K1_a) / (Inter_b - Inter_a).norm();
+               faceLayer->PushDotP(d);
+               //faceLayer->PushDotP(layer_info->vec_curvature_info[i]->K1);
+       }
+
+       // Make the values relevant by checking whether all principal directions have the "same" direction:
+       Vec3r e0((layer_info->vec_curvature_info[0]->K1 * layer_info->vec_curvature_info[0]->e1));
+       e0.normalize();
+       Vec3r e1((layer_info->vec_curvature_info[1]->K1 * layer_info->vec_curvature_info[1]->e1));
+       e1.normalize();
+       Vec3r e2((layer_info->vec_curvature_info[2]->K1 * layer_info->vec_curvature_info[2]->e1));
+       e2.normalize();
+       if (e0 * e1 < 0)
+               // invert dotP[1]
+               faceLayer->ReplaceDotP(1, -faceLayer->dotP(1));
+       if (e0 * e2 < 0)
+               // invert dotP[2]
+               faceLayer->ReplaceDotP(2, -faceLayer->dotP(2));
+
+#if 0 // remove the weakest values;
+       real minDiff = (_maxK1 - _minK1) / 10.0;
+       real minDiff = _meanK1;
+       if ((faceLayer->dotP(0) < minDiff) && (faceLayer->dotP(1) < minDiff) && (faceLayer->dotP(2) < minDiff)) {
+               faceLayer->ReplaceDotP(0, 0);
+               faceLayer->ReplaceDotP(1, 0);
+               faceLayer->ReplaceDotP(2, 0);
+       }
+#endif
+}
+#endif
 
 // SUGGESTIVE CONTOURS
 //////////////////////
 
-void FEdgeXDetector::processSuggestiveContourShape(WXShape* iWShape) {
-  
-  // Here the curvatures must already have been computed
-  vector<WFace*>& wfaces = iWShape->GetFaceList();
-  vector<WFace*>::iterator f, fend;
-  for(f=wfaces.begin(), fend=wfaces.end();
-       f!=fend;
-       ++f)
-  {
-         ProcessSuggestiveContourFace((WXFace*)(*f));
-  }
+void FEdgeXDetector::processSuggestiveContourShape(WXShape *iWShape)
+{
+       // Here the curvatures must already have been computed
+       vector<WFace*>& wfaces = iWShape->GetFaceList();
+       vector<WFace*>::iterator f, fend;
+       for (f = wfaces.begin(), fend = wfaces.end(); f != fend; ++f) {
+               ProcessSuggestiveContourFace((WXFace*)(*f));
+       }
 }
 
 void FEdgeXDetector::ProcessSuggestiveContourFace(WXFace *iFace)
 {
-  WXFaceLayer *faceLayer = new WXFaceLayer(iFace, Nature::SUGGESTIVE_CONTOUR, true);
-  iFace->AddSmoothLayer(faceLayer);
-
-  unsigned int numVertices = iFace->numberOfVertices();
-  for(unsigned int i=0; i<numVertices; ++i){
-    WVertex *wv = iFace->GetVertex(i);
-    WXVertex * wxv = dynamic_cast<WXVertex*>(wv);
-    faceLayer->PushDotP(wxv->curvatures()->Kr);
-  }
-  
-  // FIXME: find a more clever way to compute the threshold
-//   real threshold = _meanKr;
-//   if(faceLayer->nPosDotP()!=numVertices){
-//     if((fabs(faceLayer->dotP(0)) < threshold) && (fabs(faceLayer->dotP(1)) < threshold) && (fabs(faceLayer->dotP(2)) < threshold)){
-//       faceLayer->ReplaceDotP(0, 0);
-//       faceLayer->ReplaceDotP(1, 0);
-//       faceLayer->ReplaceDotP(2, 0);
-//     }
-//   }
+       WXFaceLayer *faceLayer = new WXFaceLayer(iFace, Nature::SUGGESTIVE_CONTOUR, true);
+       iFace->AddSmoothLayer(faceLayer);
+
+       unsigned int numVertices = iFace->numberOfVertices();
+       for (unsigned int i = 0; i < numVertices; ++i) {
+               WVertex *wv = iFace->GetVertex(i);
+               WXVertex *wxv = dynamic_cast<WXVertex*>(wv);
+               faceLayer->PushDotP(wxv->curvatures()->Kr);
+       }
+
+#if 0 // FIXME: find a more clever way to compute the threshold
+       real threshold = _meanKr;
+       if (faceLayer->nPosDotP()!=numVertices) {
+               if ((fabs(faceLayer->dotP(0)) < threshold) && (fabs(faceLayer->dotP(1)) < threshold) &&
+                   (fabs(faceLayer->dotP(2)) < threshold)) {
+                       faceLayer->ReplaceDotP(0, 0);
+                       faceLayer->ReplaceDotP(1, 0);
+                       faceLayer->ReplaceDotP(2, 0);
+               }
+       }
+#endif
 }
 
-void FEdgeXDetector::postProcessSuggestiveContourShape(WXShape* iShape) {
-  vector<WFace*>& wfaces = iShape->GetFaceList();
-  vector<WFace*>::iterator f, fend;
-  for(f=wfaces.begin(), fend=wfaces.end();
-      f!=fend;
-      ++f)
-    {
-      postProcessSuggestiveContourFace((WXFace*)(*f));
-    }
+void FEdgeXDetector::postProcessSuggestiveContourShape(WXShape *iShape)
+{
+       vector<WFace*>& wfaces = iShape->GetFaceList();
+       vector<WFace*>::iterator f, fend;
+       for (f = wfaces.begin(), fend = wfaces.end(); f != fend; ++f) {
+               postProcessSuggestiveContourFace((WXFace*)(*f));
+       }
 }
 
-void FEdgeXDetector::postProcessSuggestiveContourFace(WXFace *iFace) {
-
-  // Compute the derivative of the radial curvature in the radial direction,
-  // at the two extremities of the smooth edge.
-  // If the derivative is smaller than a given threshold _kr_derivative_epsilon,
-  // discard the edge.
-  // Find the suggestive contour layer of the face (zero or one edge).
-  vector<WXFaceLayer*> sc_layers;
-  iFace->retrieveSmoothEdgesLayers(Nature::SUGGESTIVE_CONTOUR, sc_layers);
-  if(sc_layers.empty())
-    return;
-
-  WXFaceLayer *sc_layer;
-  sc_layer = sc_layers[0];
-
-  // Compute the derivative value at each vertex of the face, and add it in a vector.
-  vector<real> kr_derivatives;
-
-  unsigned vertices_nb = iFace->numberOfVertices();
-  WXVertex *v, *opposite_vertex_a, *opposite_vertex_b;
-  WXFace *wxf;
-  WOEdge *opposite_edge;
-  Vec3r normal_vec, radial_normal_vec, er_vec, v_vec, inter, inter1, inter2, tmp_vec;
-  GeomUtils::intersection_test res;
-  real kr(0), kr1(0), kr2(0), t;
-
-  for (unsigned i = 0; i < vertices_nb; ++i) {
-    v = (WXVertex*)(iFace->GetVertex(i));
-
-    // v is a singular vertex, skip it.
-    if (v->isBoundary()) {
-      kr_derivatives.push_back(0);
-      continue;
-    }
-
-    v_vec = v->GetVertex();
-    er_vec = v->curvatures()->er;
-    
-    // For each vertex, iterate on its adjacent faces.
-    for (WVertex::face_iterator fit = v->faces_begin(), fitend = v->faces_end();
-        fit != fitend;
-        ++fit) {  
-      wxf = dynamic_cast<WXFace*>(*fit);
-      if(!(wxf->getOppositeEdge(v, opposite_edge)))
-       continue;
-      
-      opposite_vertex_a = (WXVertex*)opposite_edge->GetaVertex();
-      opposite_vertex_b = (WXVertex*)opposite_edge->GetbVertex();
-      normal_vec = wxf->GetVertexNormal(v); // FIXME: what about e1 ^ e2 ?
-      radial_normal_vec = er_vec ^ normal_vec;
-
-      // Test wether the radial plan intersects with the edge at the opposite of v.
-      res = GeomUtils::intersectRayPlane(opposite_vertex_a->GetVertex(), opposite_edge->GetVec(),
-                                        radial_normal_vec, -(v_vec * radial_normal_vec),
-                                        t,
-                                        1.e-06);
-      
-      // If there is an intersection, compute the value of the derivative ath that point.
-      if ((res == GeomUtils::DO_INTERSECT) && (t >= 0) && (t <= 1)) {
-       kr = t * opposite_vertex_a->curvatures()->Kr + (1 - t) * opposite_vertex_b->curvatures()->Kr;
-       inter = opposite_vertex_a->GetVertex() + t * opposite_edge->GetVec();
-       tmp_vec = inter - v->GetVertex();
-       // Is it kr1 or kr2?
-       if (tmp_vec * er_vec > 0) {
-         kr2 = kr;
-         inter2 = inter;
-       } else {
-         kr1 = kr;
-         inter1 = inter;
-       }
-      }
-    }
-
-    // Now we have kr1 and kr2 along the radial direction, for one vertex of iFace.
-    // We have to compute the derivative of kr for that vertex, equal to:
-    // (kr2 - kr1) / dist(inter1, inter2).
-    // Then we add it to the vector of derivatives.
-    v->curvatures()->dKr = (kr2 - kr1) / (inter2 - inter1).norm();
-    kr_derivatives.push_back(v->curvatures()->dKr);
-  }
-
-  // At that point, we have the derivatives for each vertex of iFace.
-  // All we have to do now is to use linear interpolation to compute the values at
-  // the extremities of the smooth edge.
-  WXSmoothEdge *sc_edge = sc_layer->getSmoothEdge();
-  WOEdge *sc_oedge = sc_edge->woea();
-  t = sc_edge->ta();
-  if (t * kr_derivatives[iFace->GetIndex(sc_oedge->GetaVertex())] +
-      (1 - t) * kr_derivatives[iFace->GetIndex(sc_oedge->GetbVertex())] < _kr_derivative_epsilon) {
-    sc_layer->removeSmoothEdge();
-    return;
-  }
-  sc_oedge = sc_edge->woeb();
-  t = sc_edge->tb();
-  if (t * kr_derivatives[iFace->GetIndex(sc_oedge->GetaVertex())] +
-      (1 - t) * kr_derivatives[iFace->GetIndex(sc_oedge->GetbVertex())] < _kr_derivative_epsilon)
-    sc_layer->removeSmoothEdge();
+void FEdgeXDetector::postProcessSuggestiveContourFace(WXFace *iFace)
+{
+       // Compute the derivative of the radial curvature in the radial direction, at the two extremities of the smooth edge.
+       // If the derivative is smaller than a given threshold _kr_derivative_epsilon, discard the edge.
+
+       // Find the suggestive contour layer of the face (zero or one edge).
+       vector<WXFaceLayer*> sc_layers;
+       iFace->retrieveSmoothEdgesLayers(Nature::SUGGESTIVE_CONTOUR, sc_layers);
+       if (sc_layers.empty())
+               return;
+
+       WXFaceLayer *sc_layer;
+       sc_layer = sc_layers[0];
+
+       // Compute the derivative value at each vertex of the face, and add it in a vector.
+       vector<real> kr_derivatives;
+
+       unsigned vertices_nb = iFace->numberOfVertices();
+       WXVertex *v, *opposite_vertex_a, *opposite_vertex_b;
+       WXFace *wxf;
+       WOEdge *opposite_edge;
+       Vec3r normal_vec, radial_normal_vec, er_vec, v_vec, inter, inter1, inter2, tmp_vec;
+       GeomUtils::intersection_test res;
+       real kr(0), kr1(0), kr2(0), t;
+
+       for (unsigned int i = 0; i < vertices_nb; ++i) {
+               v = (WXVertex*)(iFace->GetVertex(i));
+
+               // v is a singular vertex, skip it.
+               if (v->isBoundary()) {
+                       kr_derivatives.push_back(0);
+                       continue;
+               }
+
+               v_vec = v->GetVertex();
+               er_vec = v->curvatures()->er;
+
+               // For each vertex, iterate on its adjacent faces.
+               for (WVertex::face_iterator fit = v->faces_begin(), fitend = v->faces_end(); fit != fitend; ++fit) {
+                       wxf = dynamic_cast<WXFace*>(*fit);
+                       if (!wxf->getOppositeEdge(v, opposite_edge))
+                               continue;
+
+                       opposite_vertex_a = (WXVertex *)opposite_edge->GetaVertex();
+                       opposite_vertex_b = (WXVertex *)opposite_edge->GetbVertex();
+                       normal_vec = wxf->GetVertexNormal(v); // FIXME: what about e1 ^ e2 ?
+                       radial_normal_vec = er_vec ^ normal_vec;
+
+                       // Test wether the radial plan intersects with the edge at the opposite of v.
+                       res = GeomUtils::intersectRayPlane(opposite_vertex_a->GetVertex(), opposite_edge->GetVec(),
+                                                          radial_normal_vec, -(v_vec * radial_normal_vec),
+                                                          t, 1.0e-06);
+
+                       // If there is an intersection, compute the value of the derivative ath that point.
+                       if ((res == GeomUtils::DO_INTERSECT) && (t >= 0) && (t <= 1)) {
+                               kr = t * opposite_vertex_a->curvatures()->Kr + (1 - t) * opposite_vertex_b->curvatures()->Kr;
+                               inter = opposite_vertex_a->GetVertex() + t * opposite_edge->GetVec();
+                               tmp_vec = inter - v->GetVertex();
+                               // Is it kr1 or kr2?
+                               if (tmp_vec * er_vec > 0) {
+                                       kr2 = kr;
+                                       inter2 = inter;
+                               }
+                               else {
+                                       kr1 = kr;
+                                       inter1 = inter;
+                               }
+                       }
+               }
+
+               // Now we have kr1 and kr2 along the radial direction, for one vertex of iFace.
+               // We have to compute the derivative of kr for that vertex, equal to:
+               // (kr2 - kr1) / dist(inter1, inter2).
+               // Then we add it to the vector of derivatives.
+               v->curvatures()->dKr = (kr2 - kr1) / (inter2 - inter1).norm();
+               kr_derivatives.push_back(v->curvatures()->dKr);
+       }
+
+       // At that point, we have the derivatives for each vertex of iFace.
+       // All we have to do now is to use linear interpolation to compute the values at the extremities of the smooth edge.
+       WXSmoothEdge *sc_edge = sc_layer->getSmoothEdge();
+       WOEdge *sc_oedge = sc_edge->woea();
+       t = sc_edge->ta();
+       if (t * kr_derivatives[iFace->GetIndex(sc_oedge->GetaVertex())] +
+           (1 - t) * kr_derivatives[iFace->GetIndex(sc_oedge->GetbVertex())] < _kr_derivative_epsilon)
+       {
+               sc_layer->removeSmoothEdge();
+               return;
+       }
+       sc_oedge = sc_edge->woeb();
+       t = sc_edge->tb();
+       if (t * kr_derivatives[iFace->GetIndex(sc_oedge->GetaVertex())] +
+           (1 - t) * kr_derivatives[iFace->GetIndex(sc_oedge->GetbVertex())] < _kr_derivative_epsilon)
+       {
+               sc_layer->removeSmoothEdge();
+       }
 }
 
 // MATERIAL_BOUNDARY
 ////////////////////
-void FEdgeXDetector::processMaterialBoundaryShape(WXShape* iWShape) {
-
-  if(!_computeViewIndependant)
-    return;
-  // Make a pass on the edges to detect material boundaries
-  vector<WEdge*>::iterator we, weend;
-  vector<WEdge*> &wedges = iWShape->getEdgeList();
-  for(we=wedges.begin(), weend=wedges.end();
-  we!=weend;
-  ++we){
-    ProcessMaterialBoundaryEdge((WXEdge*)(*we));
-  }
+void FEdgeXDetector::processMaterialBoundaryShape(WXShape *iWShape)
+{
+       if (!_computeViewIndependant)
+               return;
+       // Make a pass on the edges to detect material boundaries
+       vector<WEdge*>::iterator we, weend;
+       vector<WEdge*> &wedges = iWShape->getEdgeList();
+       for (we = wedges.begin(), weend = wedges.end(); we != weend; ++we) {
+               ProcessMaterialBoundaryEdge((WXEdge*)(*we));
+       }
 }
 
 void FEdgeXDetector::ProcessMaterialBoundaryEdge(WXEdge *iEdge)
 {
-  // check whether the edge is a material boundary?
-  WFace *aFace = iEdge->GetaFace();
-  WFace *bFace = iEdge->GetbFace();
-  if(aFace && bFace && aFace->frs_materialIndex() != bFace->frs_materialIndex()){
-    iEdge->AddNature(Nature::MATERIAL_BOUNDARY);
-  }
+       // check whether the edge is a material boundary?
+       WFace *aFace = iEdge->GetaFace();
+       WFace *bFace = iEdge->GetbFace();
+       if (aFace && bFace && aFace->frs_materialIndex() != bFace->frs_materialIndex()) {
+               iEdge->AddNature(Nature::MATERIAL_BOUNDARY);
+       }
 }
 
 // EDGE MARKS
 /////////////
-  
-void FEdgeXDetector::processEdgeMarksShape(WXShape* iShape) {
-  // Make a pass on the edges to detect material boundaries
-  vector<WEdge*>::iterator we, weend;
-  vector<WEdge*> &wedges = iShape->getEdgeList();
-  for(we=wedges.begin(), weend=wedges.end();
-  we!=weend;
-  ++we){
-    ProcessEdgeMarks((WXEdge*)(*we));
-  }
+void FEdgeXDetector::processEdgeMarksShape(WXShape *iShape)
+{
+       // Make a pass on the edges to detect material boundaries
+       vector<WEdge*>::iterator we, weend;
+       vector<WEdge*> &wedges = iShape->getEdgeList();
+       for (we = wedges.begin(), weend = wedges.end(); we != weend; ++we) {
+               ProcessEdgeMarks((WXEdge*)(*we));
+       }
 }
 
-void FEdgeXDetector::ProcessEdgeMarks(WXEdge *iEdge) {
-  if (iEdge->GetMark()) {
-    iEdge->AddNature(Nature::EDGE_MARK);
-  }
+void FEdgeXDetector::ProcessEdgeMarks(WXEdge *iEdge)
+{
+       if (iEdge->GetMark()) {
+               iEdge->AddNature(Nature::EDGE_MARK);
+       }
 }
 
 // Build Smooth edges
 /////////////////////
-void FEdgeXDetector::buildSmoothEdges(WXShape* iShape){
-  bool hasSmoothEdges = false;
-
-  // Make a last pass to build smooth edges from the previous stored values:
-  //--------------------------------------------------------------------------
-  vector<WFace*>& wfaces = iShape->GetFaceList();
-  for(vector<WFace*>::iterator f=wfaces.begin(), fend=wfaces.end();
-  f!=fend;
-  ++f)
-  {
-    vector<WXFaceLayer*>& faceLayers = ((WXFace*)(*f))->getSmoothLayers();
-    for(vector<WXFaceLayer*>::iterator wxfl = faceLayers.begin(), wxflend=faceLayers.end();
-    wxfl!=wxflend;
-    ++wxfl){
-      if ((*wxfl)->BuildSmoothEdge())
-           hasSmoothEdges = true;
-    }
-  }
-
-  if (hasSmoothEdges && !_computeRidgesAndValleys && !_computeSuggestiveContours) {
-    vector<WVertex*>& wvertices = iShape->getVertexList();
-    for(vector<WVertex*>::iterator wv=wvertices.begin(), wvend=wvertices.end(); 
-    wv!=wvend;
-    ++wv){
-      // Compute curvatures
-      WXVertex * wxv = dynamic_cast<WXVertex*>(*wv);
-      computeCurvatures(wxv);
-    }
-    _meanK1 /= (real)(_nPoints);
-    _meanKr /= (real)(_nPoints);
-  }
+void FEdgeXDetector::buildSmoothEdges(WXShape *iShape)
+{
+       bool hasSmoothEdges = false;
+
+       // Make a last pass to build smooth edges from the previous stored values:
+       //--------------------------------------------------------------------------
+       vector<WFace*>& wfaces = iShape->GetFaceList();
+       for (vector<WFace*>::iterator f = wfaces.begin(), fend = wfaces.end(); f != fend; ++f) {
+               vector<WXFaceLayer*>& faceLayers = ((WXFace*)(*f))->getSmoothLayers();
+               for (vector<WXFaceLayer*>::iterator wxfl = faceLayers.begin(), wxflend = faceLayers.end();
+                    wxfl != wxflend;
+                    ++wxfl)
+               {
+                       if ((*wxfl)->BuildSmoothEdge())
+                               hasSmoothEdges = true;
+               }
+       }
+
+       if (hasSmoothEdges && !_computeRidgesAndValleys && !_computeSuggestiveContours) {
+               vector<WVertex*>& wvertices = iShape->getVertexList();
+               for (vector<WVertex*>::iterator wv = wvertices.begin(), wvend = wvertices.end(); wv != wvend; ++wv) {
+                       // Compute curvatures
+                       WXVertex *wxv = dynamic_cast<WXVertex*>(*wv);
+                       computeCurvatures(wxv);
+               }
+               _meanK1 /= (real)(_nPoints);
+               _meanKr /= (real)(_nPoints);
+       }
 }
index 2fd6a4a1e8f98781d99e9d07e0cc73e625c8cd59..1b211264402614124667291f303b99a4c82e5cdc 100644 (file)
-//
-//  Filename         : FEdgeXDetector.h
-//  Author(s)        : Stephane Grabli
-//  Purpose          : Detects/flags/builds extended features edges on the
-//                     WXEdge structure
-//  Date of creation : 26/10/2003
-//
-///////////////////////////////////////////////////////////////////////////////
-
-
-//
-//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
-//   with this source distribution. 
-//
-//  This program is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU General Public License
-//  as published by the Free Software Foundation; either version 2
-//  of the License, or (at your option) any later version.
-//
-//  This program is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//  GNU General Public License for more details.
-//
-//  You should have received a copy of the GNU General Public License
-//  along with this program; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-
-#ifndef  FEDGEXDETECTOR_H
-# define FEDGEXDETECTOR_H
-
-# include <vector>
-# include "../system/FreestyleConfig.h"
-# include "../geometry/Geom.h"
-# include "../winged_edge/WXEdge.h"
-# include "../winged_edge/Curvature.h"
-# include "../system/ProgressBar.h"
-# include "../system/RenderMonitor.h"
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) 2010 Blender Foundation.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
 
-using namespace Geometry;
+#ifndef __FREESTYLE_FEDGE_X_DETECTOR_H__
+#define __FREESTYLE_FEDGE_X_DETECTOR_H__
 
-/*! This class takes as input a WXEdge structure and fills it
+/** \file blender/freestyle/intern/view_map/FEdgeXDetector.h
+ *  \ingroup freestyle
+ *  \brief Detects/flags/builds extended features edges on the WXEdge structure
+ *  \author Stephane Grabli
+ *  \date 26/10/2003
  */
 
+#include <vector>
+
+#include "../geometry/Geom.h"
+
+#include "../system/FreestyleConfig.h"
+#include "../system/ProgressBar.h"
+#include "../system/RenderMonitor.h"
+
+#include "../winged_edge/Curvature.h"
+#include "../winged_edge/WXEdge.h"
+
+using namespace Geometry;
+
+/*! This class takes as input a WXEdge structure and fills it */
 class LIB_VIEW_MAP_EXPORT FEdgeXDetector
 {
 public:
-
-  FEdgeXDetector() {
-    _pProgressBar = 0;
-    _pRenderMonitor = 0;
-    _computeViewIndependant = true;
-    _bbox_diagonal = 1.0;
-    _meanEdgeSize = 0;
-    _computeRidgesAndValleys = true;
-    _computeSuggestiveContours = true;
-       _computeMaterialBoundaries = true;
-    _sphereRadius = 1.0;
-    _orthographicProjection = false;
-    _faceSmoothness = false;
-    _changes = false;
-    _kr_derivative_epsilon = 0.0;
-       _creaseAngle = 0.7; // angle of 134.43 degrees
-  }
-  virtual ~FEdgeXDetector() {}
-
-  /*! Process shapes from a WingedEdge containing a list of WShapes */
-  virtual void processShapes(WingedEdge&);
-
-  // GENERAL STUFF
-  virtual void preProcessShape(WXShape* iShape);
-  virtual void preProcessFace(WXFace* iFace);
-  virtual void computeCurvatures(WXVertex *iVertex);
-
-  // SILHOUETTE
-  virtual void processSilhouetteShape(WXShape* iShape);
-  virtual void ProcessSilhouetteFace(WXFace *iFace);
-  virtual void ProcessSilhouetteEdge(WXEdge *iEdge);
-
-  // CREASE
-  virtual void processCreaseShape(WXShape* iShape);
-  virtual void ProcessCreaseEdge(WXEdge *iEdge);
-  /*! Sets the minimum angle for detecting crease edges
-   *  \param angle
-   *    The angular threshold in degrees (between 0 and 180) for detecting crease
-   *    edges.  An edge is considered a crease edge if the angle between two faces
-   *    sharing the edge is smaller than the given threshold.
-   */
-  inline void setCreaseAngle(real angle) {
-    if (angle < 0.0)
-      angle = 0.0;
-       else if (angle > 180.0)
-      angle = 180.0;
-    angle = cos(M_PI * (180.0 - angle) / 180.0);
-    if (angle != _creaseAngle){
-      _creaseAngle = angle;
-      _changes = true;
-    }
-  }
-
-  // BORDER
-  virtual void processBorderShape(WXShape* iShape);
-  virtual void ProcessBorderEdge(WXEdge *iEdge);
-
-  // RIDGES AND VALLEYS
-  virtual void processRidgesAndValleysShape(WXShape* iShape);
-  virtual void ProcessRidgeFace(WXFace *iFace);
-
-  // SUGGESTIVE CONTOURS
-  virtual void processSuggestiveContourShape(WXShape* iShape);
-  virtual void ProcessSuggestiveContourFace(WXFace *iFace);
-  virtual void postProcessSuggestiveContourShape(WXShape* iShape);
-  virtual void postProcessSuggestiveContourFace(WXFace *iFace);
-  /*! Sets the minimal derivative of the radial curvature for suggestive contours
-   *  \param dkr
-   *    The minimal derivative of the radial curvature
-   */
-  inline void setSuggestiveContourKrDerivativeEpsilon(real dkr) {
-    if (dkr != _kr_derivative_epsilon){
-      _kr_derivative_epsilon = dkr;
-      _changes = true;
-    }
-  }
-
-  // MATERIAL BOUNDARY
-  virtual void processMaterialBoundaryShape(WXShape* iWShape);
-  virtual void ProcessMaterialBoundaryEdge(WXEdge *iEdge);
-
-  // EDGE MARKS
-  virtual void processEdgeMarksShape(WXShape* iShape);
-  virtual void ProcessEdgeMarks(WXEdge *iEdge);
-
-  // EVERYBODY
-  virtual void buildSmoothEdges(WXShape* iShape);
-
-  /*! Sets the current viewpoint */
-  inline void setViewpoint(const Vec3r& ivp) {_Viewpoint = ivp;}
-  inline void enableOrthographicProjection(bool b) {_orthographicProjection = b;}
-  inline void enableRidgesAndValleysFlag(bool b) {_computeRidgesAndValleys = b;}
-  inline void enableSuggestiveContours(bool b) {_computeSuggestiveContours = b;}
-  inline void enableMaterialBoundaries(bool b) {_computeMaterialBoundaries = b;}
-  inline void enableFaceSmoothness(bool b) {
-    if (b != _faceSmoothness) {
-         _faceSmoothness = b;
-      _changes=true;
-    }
-  }
-  inline void enableFaceMarks(bool b) {
-    if (b != _faceMarks) {
-         _faceMarks = b;
-      _changes=true;
-    }
-  }
-  /*! Sets the radius of the geodesic sphere around each vertex (for the curvature computation)
-   *  \param r
-   *    The radius of the sphere expressed as a ratio of the mean edge size
-   */
-  inline void setSphereRadius(real r) {
-    if(r!=_sphereRadius){
-      _sphereRadius = r;
-      _changes=true;
-    }
-  }
-
-  inline void setProgressBar(ProgressBar *iProgressBar) {_pProgressBar = iProgressBar;}
-
-  inline void setRenderMonitor(RenderMonitor *iRenderMonitor) {_pRenderMonitor = iRenderMonitor;}
+       FEdgeXDetector()
+       {
+               _pProgressBar = NULL;
+               _pRenderMonitor = NULL;
+               _computeViewIndependant = true;
+               _bbox_diagonal = 1.0;
+               _meanEdgeSize = 0;
+               _computeRidgesAndValleys = true;
+               _computeSuggestiveContours = true;
+               _computeMaterialBoundaries = true;
+               _sphereRadius = 1.0;
+               _orthographicProjection = false;
+               _faceSmoothness = false;
+               _changes = false;
+               _kr_derivative_epsilon = 0.0;
+               _creaseAngle = 0.7; // angle of 134.43 degrees
+       }
+
+       virtual ~FEdgeXDetector() {}
+
+       /*! Process shapes from a WingedEdge containing a list of WShapes */
+       virtual void processShapes(WingedEdge&);
+
+       // GENERAL STUFF
+       virtual void preProcessShape(WXShape *iShape);
+       virtual void preProcessFace(WXFace *iFace);
+       virtual void computeCurvatures(WXVertex *iVertex);
+
+       // SILHOUETTE
+       virtual void processSilhouetteShape(WXShape *iShape);
+       virtual void ProcessSilhouetteFace(WXFace *iFace);
+       virtual void ProcessSilhouetteEdge(WXEdge *iEdge);
+
+       // CREASE
+       virtual void processCreaseShape(WXShape *iShape);
+       virtual void ProcessCreaseEdge(WXEdge *iEdge);
+
+       /*! Sets the minimum angle for detecting crease edges
+        *  \param angle
+        *    The angular threshold in degrees (between 0 and 180) for detecting crease edges. An edge is considered
+        *    a crease edge if the angle between two faces sharing the edge is smaller than the given threshold.
+        */
+       // XXX angle should be in radian...
+       inline void setCreaseAngle(real angle)
+       {
+               if (angle < 0.0)
+                       angle = 0.0;
+               else if (angle > 180.0)
+                       angle = 180.0;
+               angle = cos(M_PI * (180.0 - angle) / 180.0);
+               if (angle != _creaseAngle) {
+                       _creaseAngle = angle;
+                       _changes = true;
+               }
+       }
+
+       // BORDER
+       virtual void processBorderShape(WXShape *iShape);
+       virtual void ProcessBorderEdge(WXEdge *iEdge);
+
+       // RIDGES AND VALLEYS
+       virtual void processRidgesAndValleysShape(WXShape *iShape);
+       virtual void ProcessRidgeFace(WXFace *iFace);
+
+       // SUGGESTIVE CONTOURS
+       virtual void processSuggestiveContourShape(WXShape *iShape);
+       virtual void ProcessSuggestiveContourFace(WXFace *iFace);
+       virtual void postProcessSuggestiveContourShape(WXShape *iShape);
+       virtual void postProcessSuggestiveContourFace(WXFace *iFace);
+       /*! Sets the minimal derivative of the radial curvature for suggestive contours
+        *  \param dkr
+        *    The minimal derivative of the radial curvature
+        */
+       inline void setSuggestiveContourKrDerivativeEpsilon(real dkr)
+       {
+               if (dkr != _kr_derivative_epsilon) {
+                       _kr_derivative_epsilon = dkr;
+                       _changes = true;
+               }
+       }
+
+       // MATERIAL BOUNDARY
+       virtual void processMaterialBoundaryShape(WXShape *iWShape);
+       virtual void ProcessMaterialBoundaryEdge(WXEdge *iEdge);
+
+       // EDGE MARKS
+       virtual void processEdgeMarksShape(WXShape *iShape);
+       virtual void ProcessEdgeMarks(WXEdge *iEdge);
+
+       // EVERYBODY
+       virtual void buildSmoothEdges(WXShape *iShape);
+
+       /*! Sets the current viewpoint */
+       inline void setViewpoint(const Vec3r& ivp)
+       {
+               _Viewpoint = ivp;
+       }
+
+       inline void enableOrthographicProjection(bool b)
+       {
+               _orthographicProjection = b;
+       }
+
+       inline void enableRidgesAndValleysFlag(bool b)
+       {
+               _computeRidgesAndValleys = b;
+       }
+
+       inline void enableSuggestiveContours(bool b)
+       {
+               _computeSuggestiveContours = b;
+       }
+
+       inline void enableMaterialBoundaries(bool b)
+       {
+               _computeMaterialBoundaries = b;
+       }
+
+       inline void enableFaceSmoothness(bool b)
+       {
+               if (b != _faceSmoothness) {
+                       _faceSmoothness = b;
+                       _changes=true;
+               }
+       }
+
+       inline void enableFaceMarks(bool b)
+       {
+               if (b != _faceMarks) {
+                       _faceMarks = b;
+                       _changes=true;
+               }
+       }
+
+       /*! Sets the radius of the geodesic sphere around each vertex (for the curvature computation)
+        *  \param r
+        *    The radius of the sphere expressed as a ratio of the mean edge size
+        */
+       inline void setSphereRadius(real r)
+       {
+               if (r != _sphereRadius) {
+                       _sphereRadius = r;
+                       _changes=true;
+               }
+       }
+
+       inline void setProgressBar(ProgressBar *iProgressBar)
+       {
+               _pProgressBar = iProgressBar;
+       }
+
+       inline void setRenderMonitor(RenderMonitor *iRenderMonitor)
+       {
+               _pRenderMonitor = iRenderMonitor;
+       }
 
 protected:
-
-  Vec3r _Viewpoint;
-  real _bbox_diagonal; // diagonal of the current processed shape bbox
-  //oldtmp values
-  bool _computeViewIndependant;
-  real _meanK1;
-  real _meanKr;
-  real _minK1;
-  real _minKr;
-  real _maxK1;
-  real _maxKr;
-  unsigned _nPoints;
-  real _meanEdgeSize;
-  bool _orthographicProjection;
-
-  bool _computeRidgesAndValleys;
-  bool _computeSuggestiveContours;
-  bool _computeMaterialBoundaries;
-  bool _faceSmoothness;
-  bool _faceMarks;
-  real _sphereRadius; // expressed as a ratio of the mean edge size
-  real _creaseAngle; // [-1, 1] compared with the inner product of face normals
-  bool _changes;
-
-  real _kr_derivative_epsilon;
-
-  ProgressBar *_pProgressBar;
-  RenderMonitor *_pRenderMonitor;
+       Vec3r _Viewpoint;
+       real _bbox_diagonal; // diagonal of the current processed shape bbox
+       //oldtmp values
+       bool _computeViewIndependant;
+       real _meanK1;
+       real _meanKr;
+       real _minK1;
+       real _minKr;
+       real _maxK1;
+       real _maxKr;
+       unsigned _nPoints;
+       real _meanEdgeSize;
+       bool _orthographicProjection;
+
+       bool _computeRidgesAndValleys;
+       bool _computeSuggestiveContours;
+       bool _computeMaterialBoundaries;
+       bool _faceSmoothness;
+       bool _faceMarks;
+       real _sphereRadius; // expressed as a ratio of the mean edge size
+       real _creaseAngle; // [-1, 1] compared with the inner product of face normals
+       bool _changes;
+
+       real _kr_derivative_epsilon;
+
+       ProgressBar *_pProgressBar;
+       RenderMonitor *_pRenderMonitor;
 };
 
-#endif // FEDGEDXETECTOR_H
+#endif // __FREESTYLE_FEDGE_X_DETECTOR_H__
index a9f997e66b0068ea77b26b3954bee2d585acbc27..b6821afcb9334e9203082aaddfe2e95a669099ce 100644 (file)
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) 2010 Blender Foundation.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
 
-//
-//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
-//   with this source distribution. 
-//
-//  This program is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU General Public License
-//  as published by the Free Software Foundation; either version 2
-//  of the License, or (at your option) any later version.
-//
-//  This program is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//  GNU General Public License for more details.
-//
-//  You should have received a copy of the GNU General Public License
-//  along with this program; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
-//
-///////////////////////////////////////////////////////////////////////////////
+/** \file blender/freestyle/intern/view_map/Functions0D.cpp
+ *  \ingroup freestyle
+ *  \brief Functions taking 0D input
+ *  \author Stephane Grabli
+ *  \author Emmanuel Turquin
+ *  \date 01/07/2003
+ */
 
-# include "Functions0D.h"
-# include "ViewMap.h"
+#include "Functions0D.h"
+#include "ViewMap.h"
 
 using namespace std;
 
 namespace Functions0D {
 
-  // Internal function
-  FEdge* getFEdge(Interface0D& it1, Interface0D& it2){
-    return it1.getFEdge(it2);
-  }
+// Internal function
+FEdge *getFEdge(Interface0D& it1, Interface0D& it2)
+{
+       return it1.getFEdge(it2);
+}
 
-  void getFEdges(Interface0DIterator& it,
-                 FEdge*& fe1,
-                 FEdge*& fe2) {
-    // count number of vertices
-    Interface0DIterator prev = it, next = it;
-    ++next;
-    int count = 1;
-    if (!it.isBegin() && !next.isEnd()) {
-      count = 3;
-    } 
-    if(count < 3)
-      {
-        // if we only have 2 vertices
-        FEdge * fe = 0;
-        Interface0DIterator tmp = it;
-        if(it.isBegin())
-          {
-            ++tmp;
-            fe = it->getFEdge(*tmp);
-          }
-        else
-          {
-            --tmp;
-            fe = it->getFEdge(*tmp);
-          }
-        fe1 = fe;
-        fe2 = 0;
-      }  
-    else 
-      {
-        // we have more than 2 vertices
-        bool begin=false,last=false;
-        Interface0DIterator previous = it;
-        if(!previous.isBegin())
-          --previous;
-        else
-          begin=true;
-        Interface0DIterator next = it;
-        ++next;
-        if(next.isEnd())
-          last = true;
-        if(begin)
-          {
-            fe1 = it->getFEdge(*next);
-            fe2 = 0;
-          }
-        else if(last)
-          {
-            fe1 = previous->getFEdge(*it);
-            fe2 = 0;
-          }
-        else
-          {
-            fe1 = previous->getFEdge(*it);
-            fe2 = it->getFEdge(*next);
-          }
-      }
-  }
+void getFEdges(Interface0DIterator& it, FEdge *&fe1, FEdge *&fe2)
+{
+       // count number of vertices
+       Interface0DIterator prev = it, next = it;
+       ++next;
+       int count = 1;
+       if (!it.isBegin() && !next.isEnd()) {
+               count = 3;
+       }
+       if (count < 3) {
+               // if we only have 2 vertices
+               FEdge *fe = 0;
+               Interface0DIterator tmp = it;
+               if (it.isBegin()) {
+                       ++tmp;
+                       fe = it->getFEdge(*tmp);
+               }
+               else {
+                       --tmp;
+                       fe = it->getFEdge(*tmp);
+               }
+               fe1 = fe;
+               fe2 = NULL;
+       }
+       else {
+               // we have more than 2 vertices
+               bool begin = false, last = false;
+               Interface0DIterator previous = it;
+               if (!previous.isBegin())
+                       --previous;
+               else
+                       begin = true;
+               Interface0DIterator next = it;
+               ++next;
+               if (next.isEnd())
+                       last = true;
+               if (begin) {
+                       fe1 = it->getFEdge(*next);
+                       fe2 = NULL;
+               }
+               else if (last) {
+                       fe1 = previous->getFEdge(*it);
+                       fe2 = NULL;
+               }
+               else {
+                       fe1 = previous->getFEdge(*it);
+                       fe2 = it->getFEdge(*next);
+               }
+       }
+}
 
-  void getViewEdges(Interface0DIterator &it,
-                    ViewEdge *&ve1,
-                    ViewEdge *&ve2)
-  {
-    FEdge * fe1, *fe2;
-    getFEdges(it, fe1, fe2);
-    ve1 = fe1->viewedge();
-    if(fe2 != 0)
-      {
-        ve2 = fe2->viewedge();
-        if(ve2 == ve1)
-          ve2 = 0;
-      }
-    else
-      ve2 = 0;
-  }
+void getViewEdges(Interface0DIterator &it, ViewEdge *&ve1, ViewEdge *&ve2)
+{
+       FEdge *fe1, *fe2;
+       getFEdges(it, fe1, fe2);
+       ve1 = fe1->viewedge();
+       if (fe2 != NULL) {
+               ve2 = fe2->viewedge();
+               if (ve2 == ve1)
+                       ve2 = NULL;
+       }
+       else {
+               ve2 = NULL;
+       }
+}
 
-  ViewShape* getShapeF0D(Interface0DIterator& it)
-  {
-    ViewEdge *ve1, *ve2;
-    getViewEdges(it, ve1, ve2);
-    return ve1->viewShape();
-  }
+ViewShape *getShapeF0D(Interface0DIterator& it)
+{
+       ViewEdge *ve1, *ve2;
+       getViewEdges(it, ve1, ve2);
+       return ve1->viewShape();
+}
 
-  void getOccludersF0D(Interface0DIterator& it, set<ViewShape*>& oOccluders){
-    ViewEdge * ve1, *ve2;
-    getViewEdges(it, ve1, ve2);
-    occluder_container::const_iterator oit = ve1->occluders_begin();
-    occluder_container::const_iterator oitend = ve1->occluders_end();
+void getOccludersF0D(Interface0DIterator& it, set<ViewShape*>& oOccluders)
+{
+       ViewEdge *ve1, *ve2;
+       getViewEdges(it, ve1, ve2);
+       occluder_container::const_iterator oit = ve1->occluders_begin();
+       occluder_container::const_iterator oitend = ve1->occluders_end();
 
-    for(;oit!=oitend; ++oit)
-      oOccluders.insert((*oit));  
+       for (; oit != oitend; ++oit)
+               oOccluders.insert((*oit));
 
-    if(ve2!=0){
-      oit = ve2->occluders_begin();
-      oitend = ve2->occluders_end();
-      for(;oit!=oitend; ++oit)
-        oOccluders.insert((*oit)); 
-    }
-  }
+       if (ve2 != NULL) {
+               oit = ve2->occluders_begin();
+               oitend = ve2->occluders_end();
+               for (; oit != oitend; ++oit)
+                       oOccluders.insert((*oit));
+       }
+}
 
-  ViewShape * getOccludeeF0D(Interface0DIterator& it){
-    ViewEdge * ve1, *ve2;
-    getViewEdges(it, ve1, ve2);
-    ViewShape *aShape = ve1->aShape();
-    return aShape;
-  }
-    
-  //
-  int VertexOrientation2DF0D::operator()(Interface0DIterator& iter) {
-    Vec2f A,C;
-    Vec2f B(iter->getProjectedX(), iter->getProjectedY());
-    if(iter.isBegin())
-      A = Vec2f(iter->getProjectedX(), iter->getProjectedY());
-    else
-      {
-       Interface0DIterator previous = iter;
-       --previous ;
-       A = Vec2f(previous->getProjectedX(), previous->getProjectedY());
-      }
-    Interface0DIterator next = iter;
-    ++next ;
-    if(next.isEnd())
-      C = Vec2f(iter->getProjectedX(), iter->getProjectedY());
-    else
-      C = Vec2f(next->getProjectedX(), next->getProjectedY());
+ViewShape *getOccludeeF0D(Interface0DIterator& it)
+{
+       ViewEdge *ve1, *ve2;
+       getViewEdges(it, ve1, ve2);
+       ViewShape *aShape = ve1->aShape();
+       return aShape;
+}
 
-    Vec2f AB(B-A);
-    if(AB.norm() != 0)
-      AB.normalize();
-    Vec2f BC(C-B);
-    if(BC.norm() != 0)
-      BC.normalize();
-    result = AB + BC;
-    if(result.norm() != 0)
-      result.normalize();
-    return 0;
-  }
+//
+int VertexOrientation2DF0D::operator()(Interface0DIterator& iter)
+{
+       Vec2f A, C;
+       Vec2f B(iter->getProjectedX(), iter->getProjectedY());
+       if (iter.isBegin()) {
+               A = Vec2f(iter->getProjectedX(), iter->getProjectedY());
+       }
+       else {
+               Interface0DIterator previous = iter;
+               --previous ;
+               A = Vec2f(previous->getProjectedX(), previous->getProjectedY());
+       }
+       Interface0DIterator next = iter;
+       ++next;
+       if (next.isEnd())
+               C = Vec2f(iter->getProjectedX(), iter->getProjectedY());
+       else
+               C = Vec2f(next->getProjectedX(), next->getProjectedY());
 
-  int VertexOrientation3DF0D::operator()(Interface0DIterator& iter) {
-    Vec3r A,C;
-    Vec3r B(iter->getX(), iter->getY(), iter->getZ());
-    if(iter.isBegin())
-      A = Vec3r(iter->getX(), iter->getY(), iter->getZ());
-    else
-      {
+       Vec2f AB(B - A);
+       if (AB.norm() != 0)
+               AB.normalize();
+       Vec2f BC(C - B);
+       if (BC.norm() != 0)
+               BC.normalize();
+       result = AB + BC;
+       if (result.norm() != 0)
+               result.normalize();
+       return 0;
+}
+
+int VertexOrientation3DF0D::operator()(Interface0DIterator& iter)
+{
+       Vec3r A, C;
+       Vec3r B(iter->getX(), iter->getY(), iter->getZ());
+       if (iter.isBegin()) {
+               A = Vec3r(iter->getX(), iter->getY(), iter->getZ());
+       }
+       else {
        Interface0DIterator previous = iter;
        --previous ;
        A = Vec3r(previous->getX(), previous->getY(), previous->getZ());
-      }
-    Interface0DIterator next = iter;
-    ++next ;
-    if(next.isEnd())
-      C = Vec3r(iter->getX(), iter->getY(), iter->getZ());
-    else
-      C = Vec3r(next->getX(), next->getY(), next->getZ());
+       }
+       Interface0DIterator next = iter;
+       ++next ;
+       if (next.isEnd())
+               C = Vec3r(iter->getX(), iter->getY(), iter->getZ());
+       else
+               C = Vec3r(next->getX(), next->getY(), next->getZ());
 
-    Vec3r AB(B-A);
-    if(AB.norm() != 0)
-      AB.normalize();
-    Vec3r BC(C-B);
-    if(BC.norm() != 0)
-      BC.normalize();
-    result = AB + BC;
-    if(result.norm() != 0)
-      result.normalize();
-    return 0;
-  }
+       Vec3r AB(B - A);
+       if (AB.norm() != 0)
+               AB.normalize();
+       Vec3r BC(C - B);
+       if (BC.norm() != 0)
+               BC.normalize();
+       result = AB + BC;
+       if (result.norm() != 0)
+               result.normalize();
+       return 0;
+}
 
-  int Curvature2DAngleF0D::operator()(Interface0DIterator& iter) {
-    Interface0DIterator tmp1 = iter, tmp2 = iter;
-    ++tmp2;
-    unsigned count = 1;
-    while((!tmp1.isBegin()) && (count < 3))
-      {
-       --tmp1;
-       ++count;
-      }
-    while((!tmp2.isEnd()) && (count < 3))
-      {
+int Curvature2DAngleF0D::operator()(Interface0DIterator& iter)
+{
+       Interface0DIterator tmp1 = iter, tmp2 = iter;
        ++tmp2;
-       ++count;
-      }
-       if(count < 3) {
-         // if we only have 2 vertices
-         result = 0;
-      return 0;
+       unsigned count = 1;
+       while ((!tmp1.isBegin()) && (count < 3)) {
+               --tmp1;
+               ++count;
+       }
+       while ((!tmp2.isEnd()) && (count < 3)) {
+               ++tmp2;
+               ++count;
+       }
+       if (count < 3) {
+               // if we only have 2 vertices
+               result = 0;
+               return 0;
        }
 
-    Interface0DIterator v = iter;
-    if(iter.isBegin())
-      ++v;
-    Interface0DIterator next=v;
-    ++next;
-    if(next.isEnd())
-      {
-       next = v;
-       --v;
-      }
-    Interface0DIterator prev=v;
-    --prev;
+       Interface0DIterator v = iter;
+       if (iter.isBegin())
+               ++v;
+       Interface0DIterator next = v;
+       ++next;
+       if (next.isEnd()) {
+               next = v;
+               --v;
+       }
+       Interface0DIterator prev = v;
+       --prev;
 
-    Vec2r A(prev->getProjectedX(), prev->getProjectedY());
-    Vec2r B(v->getProjectedX(), v->getProjectedY());
-    Vec2r C(next->getProjectedX(), next->getProjectedY());
-    Vec2r AB(B-A);
-    Vec2r BC(C-B);
-    Vec2r N1(-AB[1], AB[0]);
-    if(N1.norm() != 0)
-      N1.normalize();
-    Vec2r N2(-BC[1], BC[0]);
-    if(N2.norm() != 0)
-      N2.normalize();
-    if((N1.norm() == 0) && (N2.norm() == 0))
-      {
-       Exception::raiseException();
-       result = 0;
-       return -1; 
-      }
-    double cosin = N1*N2;
-    if(cosin > 1)
-      cosin = 1;
-    if(cosin < -1)
-      cosin = -1;
-    result = acos(cosin);
+       Vec2r A(prev->getProjectedX(), prev->getProjectedY());
+       Vec2r B(v->getProjectedX(), v->getProjectedY());
+       Vec2r C(next->getProjectedX(), next->getProjectedY());
+       Vec2r AB(B - A);
+       Vec2r BC(C - B);
+       Vec2r N1(-AB[1], AB[0]);
+       if (N1.norm() != 0)
+               N1.normalize();
+       Vec2r N2(-BC[1], BC[0]);
+       if (N2.norm() != 0)
+               N2.normalize();
+       if ((N1.norm() == 0) && (N2.norm() == 0)) {
+               Exception::raiseException();
+               result = 0;
+               return -1; 
+       }
+       double cosin = N1 * N2;
+       if (cosin > 1)
+               cosin = 1;
+       if (cosin < -1)
+               cosin = -1;
+       result = acos(cosin);
        return 0;
-  }
+}
 
-  int ZDiscontinuityF0D::operator()(Interface0DIterator& iter) {
-    FEdge *fe1, *fe2;
-    getFEdges(iter, fe1, fe2);
-    result = fe1->z_discontinuity();
-    if(fe2!=0){
-      result += fe2->z_discontinuity();
-      result /= 2.f;
-    }
-    return 0;
-  }
+int ZDiscontinuityF0D::operator()(Interface0DIterator& iter)
+{
+       FEdge *fe1, *fe2;
+       getFEdges(iter, fe1, fe2);
+       result = fe1->z_discontinuity();
+       if (fe2 != NULL) {
+               result += fe2->z_discontinuity();
+               result /= 2.0f;
+       }
+       return 0;
+}
 
-  int Normal2DF0D::operator()(Interface0DIterator& iter) {
-    FEdge *fe1, *fe2;
-    getFEdges(iter,fe1,fe2);
-    Vec3f e1(fe1->orientation2d());
-    Vec2f n1(e1[1], -e1[0]);
-    Vec2f n(n1);
-    if(fe2 != 0)
-      {
-       Vec3f e2(fe2->orientation2d());
-       Vec2f n2(e2[1], -e2[0]);
-       n += n2;
-      }
-    n.normalize();
-    result = n;
+int Normal2DF0D::operator()(Interface0DIterator& iter)
+{
+       FEdge *fe1, *fe2;
+       getFEdges(iter, fe1, fe2);
+       Vec3f e1(fe1->orientation2d());
+       Vec2f n1(e1[1], -e1[0]);
+       Vec2f n(n1);
+       if (fe2 != NULL) {
+               Vec3f e2(fe2->orientation2d());
+               Vec2f n2(e2[1], -e2[0]);
+               n += n2;
+       }
+       n.normalize();
+       result = n;
        return 0;
-  }
+}
 
-  int MaterialF0D::operator()(Interface0DIterator& iter) {
-    FEdge *fe1, *fe2;
-    getFEdges(iter,fe1,fe2);
-    if(fe1 == 0)
-      return -1;
-    if(fe1->isSmooth())
-      result = ((FEdgeSmooth*)fe1)->frs_material();
-    else
-      result = ((FEdgeSharp*)fe1)->bFrsMaterial();
-    //    const SShape * sshape = getShapeF0D(iter);
-    //    return sshape->material();
-    return 0;
-  }
+int MaterialF0D::operator()(Interface0DIterator& iter)
+{
+       FEdge *fe1, *fe2;
+       getFEdges(iter, fe1, fe2);
+       if (fe1 == NULL)
+               return -1;
+       if (fe1->isSmooth())
+               result = ((FEdgeSmooth*)fe1)->frs_material();
+       else
+               result = ((FEdgeSharp*)fe1)->bFrsMaterial();
+#if 0
+       const SShape *sshape = getShapeF0D(iter);
+       return sshape->material();
+#endif
+       return 0;
+}
 
-  int ShapeIdF0D::operator()(Interface0DIterator& iter) {
-    ViewShape * vshape = getShapeF0D(iter);
-    result = vshape->getId();
+int ShapeIdF0D::operator()(Interface0DIterator& iter)
+{
+       ViewShape *vshape = getShapeF0D(iter);
+       result = vshape->getId();
        return 0;
-  }
+}
 
-  int QuantitativeInvisibilityF0D::operator()(Interface0DIterator& iter) {
-    ViewEdge * ve1, *ve2;
-    getViewEdges(iter,ve1,ve2);
-    unsigned int qi1, qi2;
-    qi1 = ve1->qi();
-    if(ve2 != 0){
-      qi2 = ve2->qi();
-      if(qi2!=qi1)
-        cout << "QuantitativeInvisibilityF0D: ambiguous evaluation for point " << iter->getId() << endl;
-    }
-    result = qi1;
+int QuantitativeInvisibilityF0D::operator()(Interface0DIterator& iter)
+{
+       ViewEdge *ve1, *ve2;
+       getViewEdges(iter, ve1, ve2);
+       unsigned int qi1, qi2;
+       qi1 = ve1->qi();
+       if (ve2 != NULL) {
+               qi2 = ve2->qi();
+               if (qi2 != qi1)
+                       cout << "QuantitativeInvisibilityF0D: ambiguous evaluation for point " << iter->getId() << endl;
+       }
+       result = qi1;
        return 0;
-  }
+}
 
-  int CurveNatureF0D::operator()(Interface0DIterator& iter) {
-    Nature::EdgeNature nat = 0;
-    ViewEdge * ve1, *ve2;
-    getViewEdges(iter, ve1, ve2);
-    nat |= ve1->getNature();
-    if(ve2!=0)
-      nat |= ve2->getNature();
-    result = nat;
+int CurveNatureF0D::operator()(Interface0DIterator& iter)
+{
+       Nature::EdgeNature nat = 0;
+       ViewEdge *ve1, *ve2;
+       getViewEdges(iter, ve1, ve2);
+       nat |= ve1->getNature();
+       if (ve2 != NULL)
+               nat |= ve2->getNature();
+       result = nat;
        return 0;
-  }
+}
 
-  int GetOccludersF0D::operator()(Interface0DIterator& iter) {
-    set<ViewShape*> occluders;
-    getOccludersF0D(iter,occluders);
+int GetOccludersF0D::operator()(Interface0DIterator& iter)
+{
+       set<ViewShape*> occluders;
+       getOccludersF0D(iter, occluders);
        result.clear();
-    // vsOccluders.insert(vsOccluders.begin(), occluders.begin(), occluders.end());
-    for(set<ViewShape*>::iterator it=occluders.begin(), itend=occluders.end();
-    it!=itend;
-    ++it){
-      result.push_back((*it));
-    }
+       //vsOccluders.insert(vsOccluders.begin(), occluders.begin(), occluders.end());
+       for (set<ViewShape*>::iterator it = occluders.begin(), itend = occluders.end(); it != itend; ++it) {
+               result.push_back((*it));
+       }
        return 0;
-  }
+}
 
-  int GetShapeF0D::operator()(Interface0DIterator& iter) {
-    result = getShapeF0D(iter);
+int GetShapeF0D::operator()(Interface0DIterator& iter)
+{
+       result = getShapeF0D(iter);
        return 0;
-  }
+}
 
-  int GetOccludeeF0D::operator()(Interface0DIterator& iter) {
-    result = getOccludeeF0D(iter);
+int GetOccludeeF0D::operator()(Interface0DIterator& iter)
+{
+       result = getOccludeeF0D(iter);
        return 0;
-  }
+}
 
 } // end of namespace Functions0D
index 4adbc8a1bf56cb197177845e89991cc806c308a1..03ab008736c4d0d2b52449e648ca6bbe98bc1760 100644 (file)
@@ -1,64 +1,70 @@
-//
-//  Filename         : Functions0D.h
-//  Author(s)        : Stephane Grabli, Emmanuel Turquin
-//  Purpose          : Functions taking 0D input
-//  Date of creation : 01/07/2003
-//
-///////////////////////////////////////////////////////////////////////////////
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) 2010 Blender Foundation.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
 
+#ifndef __FREESTYLE_FUNCTIONS_0D_H__
+#define __FREESTYLE_FUNCTIONS_0D_H__
+
+/** \file blender/freestyle/intern/view_map/Functions0D.h
+ *  \ingroup freestyle
+ *  \brief Functions taking 0D input
+ *  \author Stephane Grabli
+ *  \author Emmanuel Turquin
+ *  \date 01/07/2003
+ */
+
+#include <set>
+#include <vector>
+
+#include "Interface0D.h"
+
+#include "../geometry/Geom.h"
+
+#include "../python/Director.h"
+
+#include "../scene_graph/FrsMaterial.h"
+
+#include "../system/Exception.h"
+#include "../system/Precision.h"
 
-//
-//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
-//   with this source distribution. 
-//
-//  This program is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU General Public License
-//  as published by the Free Software Foundation; either version 2
-//  of the License, or (at your option) any later version.
-//
-//  This program is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//  GNU General Public License for more details.
-//
-//  You should have received a copy of the GNU General Public License
-//  along with this program; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef  FUNCTIONS0D_H
-# define FUNCTIONS0D_H
-
-# include "../system/Precision.h"
-# include "Interface0D.h"
-# include "../geometry/Geom.h"
-# include "../system/Exception.h"
-# include "../scene_graph/FrsMaterial.h"
-# include <set>
-# include <vector>
 class FEdge;
 class ViewEdge;
 class SShape;
 
 using namespace Geometry;
 
-#include "../python/Director.h"
-
 //
 // UnaryFunction0D (base class for functions in 0D)
 //
 ///////////////////////////////////////////////////////////
 
-template <class T>
-/*! Base class for Unary Functions (functors) working
- *  on Interface0DIterator.
- *  A unary function will be used by calling
- *  its operator() on an Interface0DIterator.
- *  \attention In the scripting language, there exists
- *  several prototypes depending on the returned value type.
- *  For example, you would inherit from a UnaryFunction0DDouble
- *  if you wish to define a function that returns a double.
+/*! Base class for Unary Functions (functors) working on Interface0DIterator.
+ *  A unary function will be used by calling its operator() on an Interface0DIterator.
+ *  \attention In the scripting language, there exists several prototypes depending on the returned value type.
+ *  For example, you would inherit from a UnaryFunction0DDouble if you wish to define a function that returns a double.
  *  The different existing prototypes are:
  *    - UnaryFunction0DVoid
  *    - UnaryFunction0DUnsigned
@@ -68,433 +74,459 @@ template <class T>
  *    - UnaryFunction0DVec2f
  *    - UnaryFunction0DVec3f
  */
+template <class T>
 class /*LIB_VIEW_MAP_EXPORT*/ UnaryFunction0D
 {
 public:
-
        T result;
        PyObject *py_uf0D;
 
-  /*! The type of the value
-   *  returned by the functor.
-   */
-  typedef T ReturnedValueType;
-  /*! Default constructor. */
-UnaryFunction0D() { py_uf0D  = 0;}
-  /*! Destructor; */
-  virtual ~UnaryFunction0D() {}
-  /*! Returns the string "UnaryFunction0D" */
-  virtual string getName() const {
-    return "UnaryFunction0D";
-  }
-  /*! The operator ().
-   *  \param iter 
-   *    An Interface0DIterator pointing onto
-   *    the point at which we wish to evaluate
-   *    the function.
-   *  \return the result of the function of type T.
-   */
-  virtual int operator()(Interface0DIterator& iter) {
-       return Director_BPy_UnaryFunction0D___call__( this, py_uf0D, iter );
-  }
-
+       /*! The type of the value returned by the functor. */
+       typedef T ReturnedValueType;
+
+       /*! Default constructor. */
+       UnaryFunction0D()
+       {
+               py_uf0D = NULL;
+       }
+
+       /*! Destructor; */
+       virtual ~UnaryFunction0D() {}
+
+       /*! Returns the string "UnaryFunction0D" */
+       virtual string getName() const
+       {
+               return "UnaryFunction0D";
+       }
+
+       /*! The operator ().
+        *  \param iter
+        *    An Interface0DIterator pointing onto the point at which we wish to evaluate the function.
+        *  \return the result of the function of type T.
+        */
+       virtual int operator()(Interface0DIterator& iter)
+       {
+               return Director_BPy_UnaryFunction0D___call__(this, py_uf0D, iter);
+       }
 };
 
-# ifdef SWIG
-%feature("director")                   UnaryFunction0D<void>;
-%feature("director")                   UnaryFunction0D<unsigned>;
-%feature("director")                   UnaryFunction0D<float>;
-%feature("director")                   UnaryFunction0D<double>;
-%feature("director")                   UnaryFunction0D<Vec2f>;
-%feature("director")                   UnaryFunction0D<Vec3f>;
-%feature("director")                   UnaryFunction0D<Id>;
-
-%template(UnaryFunction0DVoid)         UnaryFunction0D<void>;
-%template(UnaryFunction0DUnsigned)     UnaryFunction0D<unsigned>;
-%template(UnaryFunction0DFloat)                UnaryFunction0D<float>;
-%template(UnaryFunction0DDouble)       UnaryFunction0D<double>;
-%template(UnaryFunction0DVec2f)                UnaryFunction0D<Vec2f>;
-%template(UnaryFunction0DVec3f)                UnaryFunction0D<Vec3f>;
-%template(UnaryFunction0DId)           UnaryFunction0D<Id>;
-%template(UnaryFunction0DViewShape)            UnaryFunction0D<ViewShape*>;
-%template(UnaryFunction0DVectorViewShape)              UnaryFunction0D<std::vector<ViewShape*> >;
-# endif // SWIG
-
+#ifdef SWIG
+%feature("director")  UnaryFunction0D<void>;
+%feature("director")  UnaryFunction0D<unsigned>;
+%feature("director")  UnaryFunction0D<float>;
+%feature("director")  UnaryFunction0D<double>;
+%feature("director")  UnaryFunction0D<Vec2f>;
+%feature("director")  UnaryFunction0D<Vec3f>;
+%feature("director")  UnaryFunction0D<Id>;
+
+%template(UnaryFunction0DVoid)             UnaryFunction0D<void>;
+%template(UnaryFunction0DUnsigned)         UnaryFunction0D<unsigned>;
+%template(UnaryFunction0DFloat)            UnaryFunction0D<float>;
+%template(UnaryFunction0DDouble)           UnaryFunction0D<double>;
+%template(UnaryFunction0DVec2f)            UnaryFunction0D<Vec2f>;
+%template(UnaryFunction0DVec3f)            UnaryFunction0D<Vec3f>;
+%template(UnaryFunction0DId)               UnaryFunction0D<Id>;
+%template(UnaryFunction0DViewShape)        UnaryFunction0D<ViewShape*>;
+%template(UnaryFunction0DVectorViewShape)  UnaryFunction0D<std::vector<ViewShape*> >;
+#endif // SWIG
 
 //
 // Functions definitions
 //
 ///////////////////////////////////////////////////////////
 class ViewShape;
+
 namespace Functions0D {
 
-  // GetXF0D
-  /*! Returns the X 3D coordinate of an Interface0D. */
-  class LIB_VIEW_MAP_EXPORT GetXF0D : public UnaryFunction0D<real>
-  {
-  public:
-    /*! Returns the string "GetXF0D"*/
-    string getName() const {
-      return "GetXF0D";
-    }
-    /*! the () operator.*/
-    int operator()(Interface0DIterator& iter) {
-      result = iter->getX();
-         return 0;
-    }
-  };
-
-  // GetYF0D
-  /*! Returns the Y 3D coordinate of an Interface0D. */
-  class LIB_VIEW_MAP_EXPORT GetYF0D : public UnaryFunction0D<real>
-  {
-  public:
-    /*! Returns the string "GetYF0D"*/
-    string getName() const {
-      return "GetYF0D";
-    }
-    /*! the () operator.*/
-    int operator()(Interface0DIterator& iter) {
-      result = iter->getY();
-         return 0;
-    }
-  };
-
-  // GetZF0D
-  /*! Returns the Z 3D coordinate of an Interface0D. */
-  class LIB_VIEW_MAP_EXPORT GetZF0D : public UnaryFunction0D<real>
-  {
-  public:
-    /*! Returns the string "GetZF0D"*/
-    string getName() const {
-      return "GetZF0D";
-    }
-    /*! the () operator.*/
-    int operator()(Interface0DIterator& iter) {
-      result = iter->getZ();
-         return 0;
-    }
-  };
-
-  // GetProjectedXF0D
-  /*! Returns the X 3D projected coordinate of an Interface0D. */
-  class LIB_VIEW_MAP_EXPORT GetProjectedXF0D : public UnaryFunction0D<real>
-  {
-  public:
-    /*! Returns the string "GetProjectedXF0D"*/
-    string getName() const {
-      return "GetProjectedXF0D";
-    }
-    /*! the () operator.*/
-    int operator()(Interface0DIterator& iter) {
-      result = iter->getProjectedX();
-         return 0;
-    }
-  };
-
-  // GetProjectedYF0D
-  /*! Returns the Y projected 3D coordinate of an Interface0D. */
-  class LIB_VIEW_MAP_EXPORT GetProjectedYF0D : public UnaryFunction0D<real>
-  {
-  public:
-    /*! Returns the string "GetProjectedYF0D"*/
-    string getName() const {
-      return "GetProjectedYF0D";
-    }
-    /*! the () operator.*/
-    int operator()(Interface0DIterator& iter) {
-      result = iter->getProjectedY();
-         return 0;
-    }
-  };
-
-  // GetProjectedZF0D
-  /*! Returns the Z projected 3D coordinate of an Interface0D. */
-  class LIB_VIEW_MAP_EXPORT GetProjectedZF0D : public UnaryFunction0D<real>
-  {
-  public:
-    /*! Returns the string "GetProjectedZF0D"*/
-    string getName() const {
-      return "GetProjectedZF0D";
-    }
-    /*! the () operator.*/
-    int operator()(Interface0DIterator& iter) {
-      result = iter->getProjectedZ();
-         return 0;
-    }
-  };
-
-  // GetCurvilinearAbscissaF0D
-  /*! Returns the curvilinear abscissa of an Interface0D in the context of its 1D element. */
-  class LIB_VIEW_MAP_EXPORT GetCurvilinearAbscissaF0D : public UnaryFunction0D<float>
-  {
-  public:
-    /*! Returns the string "GetCurvilinearAbscissaF0D"*/
-    string getName() const {
-      return "GetCurvilinearAbscissaF0D";
-    }
-    /*! the () operator.*/
-    int operator()(Interface0DIterator& iter) {
-      result = iter.t();
-         return 0;
-    }
-  };
-
-  // GetParameterF0D
-  /*! Returns the parameter of an Interface0D in the context of its 1D element. */
-  class LIB_VIEW_MAP_EXPORT GetParameterF0D : public UnaryFunction0D<float>
-  {
-  public:
-    /*! Returns the string "GetCurvilinearAbscissaF0D"*/
-    string getName() const {
-      return "GetParameterF0D";
-    }
-    /*! the () operator.*/
-    int operator()(Interface0DIterator& iter) {
-      result = iter.u();
-         return 0;
-    }
-  };
-
-  // VertexOrientation2DF0D
-  /*! Returns a Vec2r giving the 2D oriented tangent to the 1D element
-   *  to which the Interface0DIterator& belongs to and
-   *  evaluated at the Interface0D pointed by this Interface0DIterator&.
-   */
-  class LIB_VIEW_MAP_EXPORT VertexOrientation2DF0D : public UnaryFunction0D<Vec2f>
-  {
-  public:
-    /*! Returns the string "VertexOrientation2DF0D"*/
-    string getName() const {
-      return "VertexOrientation2DF0D";
-    }
-    /*! the () operator.*/
-    int operator()(Interface0DIterator& iter);
-  };
-
-  // VertexOrientation3DF0D
-  /*! Returns a Vec3r giving the 3D oriented tangent to the 1D element
-   *  to which the Interface0DIterator& belongs to and
-   *  evaluated at the Interface0D pointed by this Interface0DIterator&.
-   */
-  class LIB_VIEW_MAP_EXPORT VertexOrientation3DF0D : public UnaryFunction0D<Vec3f>
-  {
-  public:
-    /*! Returns the string "VertexOrientation3DF0D"*/
-    string getName() const {
-      return "VertexOrientation3DF0D";
-    }
-    /*! the () operator.*/
-    int operator()(Interface0DIterator& iter);
-  };
-
-  // Curvature2DAngleF0D
-  /*! Returns a real giving the 2D curvature (as an angle) of the 1D element
-   *  to which the Interface0DIterator& belongs to and
-   *  evaluated at the Interface0D pointed by this Interface0DIterator&.
-   */
-  class LIB_VIEW_MAP_EXPORT Curvature2DAngleF0D : public UnaryFunction0D<real>
-  {
-  public:
-    /*! Returns the string "Curvature2DAngleF0D"*/
-    string getName() const {
-      return "Curvature2DAngleF0D";
-    }
-    /*! the () operator.*/
-    int operator()(Interface0DIterator& iter);
-  };
-
-  // ZDiscontinuity
-  /*! Returns a real giving the distance between
-   *  and Interface0D and the shape that lies behind (occludee).
-   *  This distance is evaluated in the camera space and normalized
-   *  between 0 and 1. Therefore, if no oject is occluded by the
-   *  shape to which the Interface0D belongs to, 1 is returned.
-   */
-  class LIB_VIEW_MAP_EXPORT ZDiscontinuityF0D : public UnaryFunction0D<real>
-  {
-  public:
-    /*! Returns the string "ZDiscontinuityF0D"*/
-    string getName() const {
-      return "ZDiscontinuityF0D";
-    }
-    /*! the () operator.*/
-    int operator()(Interface0DIterator& iter);
-  };
-
-  // Normal2DF0D
-  /*! Returns a Vec2f giving the normalized 2D normal to the 1D element
-   *  to which the Interface0DIterator& belongs to and
-   *  evaluated at the Interface0D pointed by this Interface0DIterator&.
-   */
-  class LIB_VIEW_MAP_EXPORT Normal2DF0D : public UnaryFunction0D<Vec2f>
-  {
-  public:
-    /*! Returns the string "Normal2DF0D"*/
-    string getName() const {
-      return "Normal2DF0D";
-    }
-    /*! the () operator.*/
-    int operator()(Interface0DIterator& iter);
-  };
-
-  // MaterialF0D
-  /*! Returns the material of the object evaluated at the Interface0D.
-   *  This evaluation can be ambiguous (in the case of a TVertex for example.
-   *  This functor tries to remove this ambiguity using the context
-   *  offered by the 1D element to which the Interface0DIterator& belongs
-   *  to and by arbitrary chosing the material of the face
-   *  that lies on its left when following the 1D element if there
-   *  are two different materials on each side of the point.
-   *  However, there still can be problematic cases, and the user willing
-   *  to deal with this cases in a specific way should implement
-   *  its own getMaterial functor.
-   */
-  class LIB_VIEW_MAP_EXPORT MaterialF0D : public UnaryFunction0D<FrsMaterial>
-  {
-  public:
-    /*! Returns the string "MaterialF0D"*/
-    string getName() const {
-      return "MaterialF0D";
-    }
-    /*! the () operator.*/
-    int operator()(Interface0DIterator& iter);
-  };
-
-  // ShapeIdF0D
-  /*! Returns the Id of the Shape the Interface0D belongs to.
-   *  This evaluation can be ambiguous (in the case of a TVertex for example).
-   *  This functor tries to remove this ambiguity using the context
-   *  offered by the 1D element to which the Interface0DIterator& belongs
-   *  to.
-   *  However, there still can be problematic cases, and the user willing
-   *  to deal with this cases in a specific way should implement
-   *  its own getShapeIdF0D functor.
-   */
-  class LIB_VIEW_MAP_EXPORT ShapeIdF0D : public UnaryFunction0D<Id>
-  {
-  public:
-    /*! Returns the string "ShapeIdF0D"*/
-    string getName() const {
-      return "ShapeIdF0D";
-    }
-    /*! the () operator.*/
-    int operator()(Interface0DIterator& iter);
-  };
-
-  // QiF0D
-  /*! Returns the quantitative invisibility of this Interface0D.
-   *  This evaluation can be ambiguous (in the case of a TVertex for example).
-   *  This functor tries to remove this ambiguity using the context
-   *  offered by the 1D element to which the Interface0DIterator& belongs
-   *  to.
-   *  However, there still can be problematic cases, and the user willing
-   *  to deal with this cases in a specific way should implement
-   *  its own getQIF0D functor.
-   */
-  class LIB_VIEW_MAP_EXPORT QuantitativeInvisibilityF0D : public UnaryFunction0D<unsigned int>
-  {
-  public:
-    /*! Returns the string "QuantitativeInvisibilityF0D"*/
-    string getName() const {
-      return "QuantitativeInvisibilityF0D";
-    }
-    /*! the () operator.*/
-    int operator()(Interface0DIterator& iter);
-  };
-
-  // CurveNatureF0D
-  /*! Returns the Nature::EdgeNature of the 1D element the
-   *  Interface0DIterator& belongs to.
-   */
-  class LIB_VIEW_MAP_EXPORT CurveNatureF0D : public UnaryFunction0D<Nature::EdgeNature>
-  {
-  public:
-    /*! Returns the string "QuantitativeInvisibilityF0D"*/
-    string getName() const {
-      return "CurveNatureF0D";
-    }
-    /*! the () operator.*/
-    int operator()(Interface0DIterator& iter);
-  };
-  
-  // GetShapeF0D
-  /*! Returns the ViewShape* 
-   *  containing the Interface0D
-   */
-  class LIB_VIEW_MAP_EXPORT GetShapeF0D : public UnaryFunction0D< ViewShape*>
-  {
-  public:
-    /*! Returns the string "GetShapeF0D"*/
-    string getName() const {
-      return "GetShapeF0D";
-    }
-    /*! the () operator.*/
-    int operator()(Interface0DIterator& iter);
-  };
-
-  // GetOccludersF0D
-  /*! Returns a vector containing the ViewShape* 
-   *  occluding the Interface0D
-   */
-  class LIB_VIEW_MAP_EXPORT GetOccludersF0D : public UnaryFunction0D< std::vector<ViewShape*> >
-  {
-  public:
-    /*! Returns the string "GetOccludersF0D"*/
-    string getName() const {
-      return "GetOccludersF0D";
-    }
-    /*! the () operator.*/
-    int operator()(Interface0DIterator& iter);
-  };
-
-  // GetOccludeeF0D
-  /*! Returns the ViewShape* 
-   *  "occluded" by the Interface0D
-   */
-  class LIB_VIEW_MAP_EXPORT GetOccludeeF0D: public UnaryFunction0D< ViewShape*>
-  {
-  public:
-    /*! Returns the string "GetOccludeeF0D"*/
-    string getName() const {
-      return "GetOccludeeF0D";
-    }
-    /*! the () operator.*/
-    int operator()(Interface0DIterator& iter);
-  };
-
-  
-
-  /////////////////////////// Internal ////////////////////////////
-
-  // getFEdge
-  LIB_VIEW_MAP_EXPORT
-  FEdge* getFEdge(Interface0D& it1, Interface0D& it2);
-
-  // getFEdges
-  LIB_VIEW_MAP_EXPORT
-  void  getFEdges(Interface0DIterator& it,
-                 FEdge*& fe1,
-                 FEdge*& fe2);
-
-  // getViewEdges
-  LIB_VIEW_MAP_EXPORT
-  void  getViewEdges(Interface0DIterator& it,
-                    ViewEdge *&ve1,
-                    ViewEdge *&ve2);
-
-  // getShapeF0D
-  LIB_VIEW_MAP_EXPORT
-  ViewShape* getShapeF0D(Interface0DIterator& it);
-
-  // getOccludersF0D
-  LIB_VIEW_MAP_EXPORT
-  void getOccludersF0D(Interface0DIterator& it, std::set<ViewShape*>& oOccluders);
-
-  // getOccludeeF0D
-  LIB_VIEW_MAP_EXPORT
-  ViewShape* getOccludeeF0D(Interface0DIterator& it);
+// GetXF0D
+/*! Returns the X 3D coordinate of an Interface0D. */
+class LIB_VIEW_MAP_EXPORT GetXF0D : public UnaryFunction0D<real>
+{
+public:
+       /*! Returns the string "GetXF0D" */
+       string getName() const
+       {
+               return "GetXF0D";
+       }
+
+       /*! the () operator. */
+       int operator()(Interface0DIterator& iter)
+       {
+               result = iter->getX();
+               return 0;
+       }
+};
+
+// GetYF0D
+/*! Returns the Y 3D coordinate of an Interface0D. */
+class LIB_VIEW_MAP_EXPORT GetYF0D : public UnaryFunction0D<real>
+{
+public:
+       /*! Returns the string "GetYF0D" */
+       string getName() const
+       {
+               return "GetYF0D";
+       }
+
+       /*! the () operator. */
+       int operator()(Interface0DIterator& iter)
+       {
+               result = iter->getY();
+               return 0;
+       }
+};
+
+// GetZF0D
+/*! Returns the Z 3D coordinate of an Interface0D. */
+class LIB_VIEW_MAP_EXPORT GetZF0D : public UnaryFunction0D<real>
+{
+public:
+       /*! Returns the string "GetZF0D" */
+       string getName() const
+       {
+               return "GetZF0D";
+       }
+
+       /*! the () operator. */
+       int operator()(Interface0DIterator& iter)
+       {
+               result = iter->getZ();
+               return 0;
+       }
+};
+
+// GetProjectedXF0D
+/*! Returns the X 3D projected coordinate of an Interface0D. */
+class LIB_VIEW_MAP_EXPORT GetProjectedXF0D : public UnaryFunction0D<real>
+{
+public:
+       /*! Returns the string "GetProjectedXF0D" */
+       string getName() const
+       {
+               return "GetProjectedXF0D";
+       }
+
+       /*! the () operator. */
+       int operator()(Interface0DIterator& iter)
+       {
+               result = iter->getProjectedX();
+               return 0;
+       }
+};
+
+// GetProjectedYF0D
+/*! Returns the Y projected 3D coordinate of an Interface0D. */
+class LIB_VIEW_MAP_EXPORT GetProjectedYF0D : public UnaryFunction0D<real>
+{
+public:
+       /*! Returns the string "GetProjectedYF0D" */
+       string getName() const
+       {
+               return "GetProjectedYF0D";
+       }
+
+       /*! the () operator. */
+       int operator()(Interface0DIterator& iter)
+       {
+               result = iter->getProjectedY();
+               return 0;
+       }
+};
+
+// GetProjectedZF0D
+/*! Returns the Z projected 3D coordinate of an Interface0D. */
+class LIB_VIEW_MAP_EXPORT GetProjectedZF0D : public UnaryFunction0D<real>
+{
+public:
+       /*! Returns the string "GetProjectedZF0D" */
+       string getName() const
+       {
+               return "GetProjectedZF0D";
+       }
+
+       /*! the () operator. */
+       int operator()(Interface0DIterator& iter)
+       {
+               result = iter->getProjectedZ();
+               return 0;
+       }
+};
+
+// GetCurvilinearAbscissaF0D
+/*! Returns the curvilinear abscissa of an Interface0D in the context of its 1D element. */
+class LIB_VIEW_MAP_EXPORT GetCurvilinearAbscissaF0D : public UnaryFunction0D<float>
+{
+public:
+       /*! Returns the string "GetCurvilinearAbscissaF0D" */
+       string getName() const
+       {
+               return "GetCurvilinearAbscissaF0D";
+       }
+
+       /*! the () operator. */
+       int operator()(Interface0DIterator& iter)
+       {
+               result = iter.t();
+               return 0;
+       }
+};
+
+// GetParameterF0D
+/*! Returns the parameter of an Interface0D in the context of its 1D element. */
+class LIB_VIEW_MAP_EXPORT GetParameterF0D : public UnaryFunction0D<float>
+{
+public:
+       /*! Returns the string "GetCurvilinearAbscissaF0D" */
+       string getName() const
+       {
+               return "GetParameterF0D";
+       }
+
+       /*! the () operator. */
+       int operator()(Interface0DIterator& iter)
+       {
+               result = iter.u();
+               return 0;
+       }
+};
+
+// VertexOrientation2DF0D
+/*! Returns a Vec2r giving the 2D oriented tangent to the 1D element to which the Interface0DIterator& belongs to and
+ *  evaluated at the Interface0D pointed by this Interface0DIterator&.
+ */
+class LIB_VIEW_MAP_EXPORT VertexOrientation2DF0D : public UnaryFunction0D<Vec2f>
+{
+public:
+       /*! Returns the string "VertexOrientation2DF0D" */
+       string getName() const
+       {
+               return "VertexOrientation2DF0D";
+       }
+
+       /*! the () operator. */
+       int operator()(Interface0DIterator& iter);
+};
+
+// VertexOrientation3DF0D
+/*! Returns a Vec3r giving the 3D oriented tangent to the 1D element to which the Interface0DIterator& belongs to and
+ *  evaluated at the Interface0D pointed by this Interface0DIterator&.
+ */
+class LIB_VIEW_MAP_EXPORT VertexOrientation3DF0D : public UnaryFunction0D<Vec3f>
+{
+public:
+       /*! Returns the string "VertexOrientation3DF0D" */
+       string getName() const
+       {
+               return "VertexOrientation3DF0D";
+       }
+
+       /*! the () operator. */
+       int operator()(Interface0DIterator& iter);
+};
+
+// Curvature2DAngleF0D
+/*! Returns a real giving the 2D curvature (as an angle) of the 1D element to which the Interface0DIterator&
+ *  belongs to and evaluated at the Interface0D pointed by this Interface0DIterator&.
+ */
+class LIB_VIEW_MAP_EXPORT Curvature2DAngleF0D : public UnaryFunction0D<real>
+{
+public:
+       /*! Returns the string "Curvature2DAngleF0D" */
+       string getName() const
+       {
+               return "Curvature2DAngleF0D";
+       }
+
+       /*! the () operator. */
+       int operator()(Interface0DIterator& iter);
+};
+
+// ZDiscontinuity
+/*! Returns a real giving the distance between and Interface0D and the shape that lies behind (occludee).
+ *  This distance is evaluated in the camera space and normalized between 0 and 1. Therefore, if no oject is occluded
+ *  by the shape to which the Interface0D belongs to, 1 is returned.
+ */
+class LIB_VIEW_MAP_EXPORT ZDiscontinuityF0D : public UnaryFunction0D<real>
+{
+public:
+       /*! Returns the string "ZDiscontinuityF0D" */
+       string getName() const
+       {
+               return "ZDiscontinuityF0D";
+       }
+
+       /*! the () operator. */
+       int operator()(Interface0DIterator& iter);
+};
+
+// Normal2DF0D
+/*! Returns a Vec2f giving the normalized 2D normal to the 1D element to which the Interface0DIterator& belongs to and
+ *  evaluated at the Interface0D pointed by this Interface0DIterator&.
+ */
+class LIB_VIEW_MAP_EXPORT Normal2DF0D : public UnaryFunction0D<Vec2f>
+{
+public:
+       /*! Returns the string "Normal2DF0D" */
+       string getName() const
+       {
+               return "Normal2DF0D";
+       }
+
+       /*! the () operator. */
+       int operator()(Interface0DIterator& iter);
+};
+
+// MaterialF0D
+/*! Returns the material of the object evaluated at the Interface0D.
+ *  This evaluation can be ambiguous (in the case of a TVertex for example.
+ *  This functor tries to remove this ambiguity using the context offered by the 1D element to which the
+ *  Interface0DIterator& belongs to and by arbitrary chosing the material of the face that lies on its left when
+ *  following the 1D element if there are two different materials on each side of the point.
+ *  However, there still can be problematic cases, and the user willing to deal with this cases in a specific way
+ *  should implement its own getMaterial functor.
+ */
+class LIB_VIEW_MAP_EXPORT MaterialF0D : public UnaryFunction0D<FrsMaterial>
+{
+public:
+       /*! Returns the string "MaterialF0D" */
+       string getName() const
+       {
+               return "MaterialF0D";
+       }
+
+       /*! the () operator. */
+       int operator()(Interface0DIterator& iter);
+};
+
+// ShapeIdF0D
+/*! Returns the Id of the Shape the Interface0D belongs to.
+ *  This evaluation can be ambiguous (in the case of a TVertex for example).
+ *  This functor tries to remove this ambiguity using the context offered by the 1D element to which the
+ *  Interface0DIterator& belongs to.
+ *  However, there still can be problematic cases, and the user willing to deal with this cases in a specific way
+ *  should implement its own getShapeIdF0D functor.
+ */
+class LIB_VIEW_MAP_EXPORT ShapeIdF0D : public UnaryFunction0D<Id>
+{
+public:
+       /*! Returns the string "ShapeIdF0D" */
+       string getName() const
+       {
+               return "ShapeIdF0D";
+       }
+
+       /*! the () operator. */
+       int operator()(Interface0DIterator& iter);
+};
+
+// QiF0D
+/*! Returns the quantitative invisibility of this Interface0D.
+*  This evaluation can be ambiguous (in the case of a TVertex for example).
+*  This functor tries to remove this ambiguity using the context offered by the 1D element to which the
+*  Interface0DIterator& belongs to.
+*  However, there still can be problematic cases, and the user willing to deal with this cases in a specific way
+*  should implement its own getQIF0D functor.
+*/
+class LIB_VIEW_MAP_EXPORT QuantitativeInvisibilityF0D : public UnaryFunction0D<unsigned int>
+{
+public:
+       /*! Returns the string "QuantitativeInvisibilityF0D" */
+       string getName() const
+       {
+               return "QuantitativeInvisibilityF0D";
+       }
+
+       /*! the () operator. */
+       int operator()(Interface0DIterator& iter);
+};
+
+// CurveNatureF0D
+/*! Returns the Nature::EdgeNature of the 1D element the Interface0DIterator& belongs to. */
+class LIB_VIEW_MAP_EXPORT CurveNatureF0D : public UnaryFunction0D<Nature::EdgeNature>
+{
+public:
+       /*! Returns the string "QuantitativeInvisibilityF0D" */
+       string getName() const
+       {
+               return "CurveNatureF0D";
+       }
+
+       /*! the () operator. */
+       int operator()(Interface0DIterator& iter);
+};
+
+// GetShapeF0D
+/*! Returns the ViewShape* containing the Interface0D */
+class LIB_VIEW_MAP_EXPORT GetShapeF0D : public UnaryFunction0D< ViewShape*>
+{
+public:
+       /*! Returns the string "GetShapeF0D" */
+       string getName() const
+       {
+               return "GetShapeF0D";
+       }
+
+       /*! the () operator. */
+       int operator()(Interface0DIterator& iter);
+};
+
+// GetOccludersF0D
+/*! Returns a vector containing the ViewShape* occluding the Interface0D */
+class LIB_VIEW_MAP_EXPORT GetOccludersF0D : public UnaryFunction0D< std::vector<ViewShape*> >
+{
+public:
+       /*! Returns the string "GetOccludersF0D" */
+       string getName() const
+       {
+               return "GetOccludersF0D";
+       }
+
+       /*! the () operator. */
+       int operator()(Interface0DIterator& iter);
+};
+
+// GetOccludeeF0D
+/*! Returns the ViewShape* "occluded" by the Interface0D */
+class LIB_VIEW_MAP_EXPORT GetOccludeeF0D: public UnaryFunction0D< ViewShape*>
+{
+public:
+       /*! Returns the string "GetOccludeeF0D" */
+       string getName() const
+       {
+               return "GetOccludeeF0D";
+       }
+
+       /*! the () operator. */
+       int operator()(Interface0DIterator& iter);
+};
+
+
+/////////////////////////// Internal ////////////////////////////
+
+// getFEdge
+LIB_VIEW_MAP_EXPORT
+FEdge *getFEdge(Interface0D& it1, Interface0D& it2);
+
+// getFEdges
+LIB_VIEW_MAP_EXPORT
+void getFEdges(Interface0DIterator& it, FEdge *&fe1, FEdge *&fe2);
+
+// getViewEdges
+LIB_VIEW_MAP_EXPORT
+void getViewEdges(Interface0DIterator& it, ViewEdge *&ve1, ViewEdge *&ve2);
+
+// getShapeF0D
+LIB_VIEW_MAP_EXPORT
+ViewShape *getShapeF0D(Interface0DIterator& it);
+
+// getOccludersF0D
+LIB_VIEW_MAP_EXPORT
+void getOccludersF0D(Interface0DIterator& it, std::set<ViewShape*>& oOccluders);
+
+// getOccludeeF0D
+LIB_VIEW_MAP_EXPORT
+ViewShape *getOccludeeF0D(Interface0DIterator& it);
 
 } // end of namespace Functions0D
 
-#endif // FUNCTIONS0D_H
+#endif // __FREESTYLE_FUNCTIONS_0D_H__
index 8545c660084608d1d983ae3fdf4e504629832e27..f17a568ffee850cc2a9d0fb636dafd8c37b57676 100644 (file)
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) 2010 Blender Foundation.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
 
-//
-//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
-//   with this source distribution. 
-//
-//  This program is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU General Public License
-//  as published by the Free Software Foundation; either version 2
-//  of the License, or (at your option) any later version.
-//
-//  This program is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//  GNU General Public License for more details.
-//
-//  You should have received a copy of the GNU General Public License
-//  along with this program; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
-//
-///////////////////////////////////////////////////////////////////////////////
+/** \file blender/freestyle/intern/view_map/Functions1D.cpp
+ *  \ingroup freestyle
+ *  \brief Functions taking 1D input
+ *  \author Stephane Grabli
+ *  \author Emmanuel Turquin
+ *  \date 01/07/2003
+ */
 
 # include "Functions1D.h"
+
 using namespace std;
 
 namespace Functions1D {
 
-  int GetXF1D::operator()(Interface1D& inter) {
-    result = integrate(_func, inter.verticesBegin(), inter.verticesEnd(), _integration);
+int GetXF1D::operator()(Interface1D& inter)
+{
+       result = integrate(_func, inter.verticesBegin(), inter.verticesEnd(), _integration);
        return 0;
-  }
+}
 
-  int GetYF1D::operator()(Interface1D& inter) {
-    result = integrate(_func, inter.verticesBegin(), inter.verticesEnd(), _integration);
+int GetYF1D::operator()(Interface1D& inter)
+{
+       result = integrate(_func, inter.verticesBegin(), inter.verticesEnd(), _integration);
        return 0;
-  }
+}
 
-  int GetZF1D::operator()(Interface1D& inter) {
-    result = integrate(_func, inter.verticesBegin(), inter.verticesEnd(), _integration);
+int GetZF1D::operator()(Interface1D& inter)
+{
+       result = integrate(_func, inter.verticesBegin(), inter.verticesEnd(), _integration);
        return 0;
-  }
+}
 
-  int GetProjectedXF1D::operator()(Interface1D& inter) {
-    result = integrate(_func, inter.verticesBegin(), inter.verticesEnd(), _integration);
+int GetProjectedXF1D::operator()(Interface1D& inter)
+{
+       result = integrate(_func, inter.verticesBegin(), inter.verticesEnd(), _integration);
        return 0;
-  }
+}
 
-  int GetProjectedYF1D::operator()(Interface1D& inter) {
-    result = integrate(_func, inter.verticesBegin(), inter.verticesEnd(), _integration);
+int GetProjectedYF1D::operator()(Interface1D& inter)
+{
+       result = integrate(_func, inter.verticesBegin(), inter.verticesEnd(), _integration);
        return 0;
-  }
+}
 
-  int GetProjectedZF1D::operator()(Interface1D& inter) {
-    result = integrate(_func, inter.verticesBegin(), inter.verticesEnd(), _integration);
+int GetProjectedZF1D::operator()(Interface1D& inter)
+{
+       result = integrate(_func, inter.verticesBegin(), inter.verticesEnd(), _integration);
        return 0;
-  }
+}
 
-  int Orientation2DF1D::operator()(Interface1D& inter) {
-    FEdge * fe = dynamic_cast<FEdge*>(&inter);
-    if(fe){
-      Vec3r res = fe->orientation2d();
-      result = Vec2f(res[0], res[1]);
-       } else {
-      result = integrate(_func, inter.verticesBegin(), inter.verticesEnd(), _integration);
+int Orientation2DF1D::operator()(Interface1D& inter)
+{
+       FEdge *fe = dynamic_cast<FEdge*>(&inter);
+       if (fe) {
+               Vec3r res = fe->orientation2d();
+               result = Vec2f(res[0], res[1]);
+       }
+       else {
+               result = integrate(_func, inter.verticesBegin(), inter.verticesEnd(), _integration);
        }
        return 0;
-  }
+}
 
-  int Orientation3DF1D::operator()(Interface1D& inter) {
-    result = integrate(_func, inter.verticesBegin(), inter.verticesEnd(), _integration);
+int Orientation3DF1D::operator()(Interface1D& inter)
+{
+       result = integrate(_func, inter.verticesBegin(), inter.verticesEnd(), _integration);
        return 0;
-  }
+}
 
-  int ZDiscontinuityF1D::operator()(Interface1D& inter) {
-    result = integrate(_func, inter.verticesBegin(), inter.verticesEnd(), _integration);
+int ZDiscontinuityF1D::operator()(Interface1D& inter)
+{
+       result = integrate(_func, inter.verticesBegin(), inter.verticesEnd(), _integration);
        return 0;
-  }
-  
-  int QuantitativeInvisibilityF1D::operator()(Interface1D& inter) {
-    ViewEdge* ve = dynamic_cast<ViewEdge*>(&inter);
+}
+
+int QuantitativeInvisibilityF1D::operator()(Interface1D& inter)
+{
+       ViewEdge *ve = dynamic_cast<ViewEdge*>(&inter);
        if (ve) {
-         result = ve->qi();
-      return 0;
+               result = ve->qi();
+               return 0;
        }
-    FEdge *fe = dynamic_cast<FEdge*>(&inter);
+       FEdge *fe = dynamic_cast<FEdge*>(&inter);
        if (fe) {
-      result = ve->qi();
-         return 0;
-       }
-    result = integrate(_func, inter.verticesBegin(), inter.verticesEnd(), _integration);
-       return 0;
-  }
-
-  int CurveNatureF1D::operator()(Interface1D& inter) {
-    ViewEdge* ve = dynamic_cast<ViewEdge*>(&inter);
-    if (ve)
-      result = ve->getNature();
-    else{
-      // we return a nature that contains every 
-      // natures of the viewedges spanned by the chain.
-      Nature::EdgeNature nat = Nature::NO_FEATURE;
-      Interface0DIterator it = inter.verticesBegin();
-      while(!it.isEnd()){
-        nat |= _func(it);
-        ++it;
-      }
-      result = nat;
-    }
-       return 0;
-  }
-  
-  int TimeStampF1D::operator()(Interface1D& inter) {
-    TimeStamp *timestamp = TimeStamp::instance();
-    inter.setTimeStamp(timestamp->getTimeStamp());
-       return 0;
-  }
-
-  int ChainingTimeStampF1D::operator()(Interface1D& inter) {
-    TimeStamp *timestamp = TimeStamp::instance();
-    ViewEdge *ve = dynamic_cast<ViewEdge*>(&inter);
-    if(ve)
-      ve->setChainingTimeStamp(timestamp->getTimeStamp());
-       return 0;
-  }
-  
-  int IncrementChainingTimeStampF1D::operator()(Interface1D& inter) {
-    ViewEdge *ve = dynamic_cast<ViewEdge*>(&inter);
-    if(ve)
-      ve->setChainingTimeStamp(ve->getChainingTimeStamp()+1);
-       return 0;
-  }
-
-  int GetShapeF1D::operator()(Interface1D& inter) {
-    vector<ViewShape*> shapesVector;
-    set<ViewShape*> shapesSet;
-    ViewEdge* ve = dynamic_cast<ViewEdge*>(&inter);
-    if (ve){
-      shapesVector.push_back(ve->viewShape());
-    }else{
-      Interface0DIterator it=inter.verticesBegin(), itend=inter.verticesEnd();
-      for(;it!=itend;++it)
-        shapesSet.insert(Functions0D::getShapeF0D(it));
-      shapesVector.insert<set<ViewShape*>::iterator>(shapesVector.begin(), shapesSet.begin(), shapesSet.end());
-    }
-    result = shapesVector;
-       return 0;
-  }
-
-  int GetOccludersF1D::operator()(Interface1D& inter) {
-    vector<ViewShape*> shapesVector;
-    set<ViewShape*> shapesSet;
-    ViewEdge* ve = dynamic_cast<ViewEdge*>(&inter);
-    if (ve){
-      result = ve->occluders();
-    }else{
-      Interface0DIterator it=inter.verticesBegin(), itend=inter.verticesEnd();
-      for(;it!=itend;++it){
-        Functions0D::getOccludersF0D(it, shapesSet);
-      }
-      shapesVector.insert(shapesVector.begin(), shapesSet.begin(), shapesSet.end());
-      result = shapesVector;
-    }
-       return 0;
-  }
-
-  int GetOccludeeF1D::operator()(Interface1D& inter) {
-    vector<ViewShape*> shapesVector;
-    set<ViewShape*> shapesSet;
-    ViewEdge* ve = dynamic_cast<ViewEdge*>(&inter);
-    if (ve){
-      ViewShape * aShape = ve->aShape();
-      shapesVector.push_back(aShape);
-    }else{
-      Interface0DIterator it=inter.verticesBegin(), itend=inter.verticesEnd();
-      for(;it!=itend;++it){
-        shapesSet.insert(Functions0D::getOccludeeF0D(it));
-      }
-    shapesVector.insert<set<ViewShape*>::iterator>(shapesVector.begin(), shapesSet.begin(), shapesSet.end());
-    }
-    result = shapesVector;
-       return 0;
-  }
-  // Internal
-  ////////////
-
-  void getOccludeeF1D(Interface1D& inter, set<ViewShape*>& oShapes){
-    ViewEdge* ve = dynamic_cast<ViewEdge*>(&inter);
-    if (ve){
-      ViewShape * aShape = ve->aShape();
-      if(aShape == 0){
-        oShapes.insert(0);
-        return;
-      }
-      oShapes.insert(aShape);
-    }
-    else{
-      Interface0DIterator it=inter.verticesBegin(), itend=inter.verticesEnd();
-      for(;it!=itend;++it)
-        oShapes.insert(Functions0D::getOccludeeF0D(it));
-    }
-  }
-
-  void getOccludersF1D(Interface1D& inter, set<ViewShape*>& oShapes){
-    ViewEdge* ve = dynamic_cast<ViewEdge*>(&inter);
-    if (ve){
-      vector<ViewShape*>& occluders = ve->occluders();
-      oShapes.insert<vector<ViewShape*>::iterator>(occluders.begin(), occluders.end());
-    }
-    else{
-      Interface0DIterator it=inter.verticesBegin(), itend=inter.verticesEnd();
-      for(;it!=itend;++it){
-        set<ViewShape*> shapes;
-        Functions0D::getOccludersF0D(it, shapes);
-        for(set<ViewShape*>::iterator s=shapes.begin(), send=shapes.end();
-            s!=send;
-            ++s)
-          oShapes.insert(*s);
-      }
-    }
-  }
-
-  void getShapeF1D(Interface1D& inter, set<ViewShape*>& oShapes){
-    ViewEdge* ve = dynamic_cast<ViewEdge*>(&inter);
-    if (ve){
-      oShapes.insert(ve->viewShape());
-    }else{
-      Interface0DIterator it=inter.verticesBegin(), itend=inter.verticesEnd();
-      for(;it!=itend;++it)
-        oShapes.insert(Functions0D::getShapeF0D(it));
-    }
-  }
+               result = ve->qi();
+               return 0;
+       }
+       result = integrate(_func, inter.verticesBegin(), inter.verticesEnd(), _integration);
+       return 0;
+}
+
+int CurveNatureF1D::operator()(Interface1D& inter)
+{
+       ViewEdge *ve = dynamic_cast<ViewEdge*>(&inter);
+       if (ve) {
+               result = ve->getNature();
+       }
+       else {
+               // we return a nature that contains every natures of the viewedges spanned by the chain.
+               Nature::EdgeNature nat = Nature::NO_FEATURE;
+               Interface0DIterator it = inter.verticesBegin();
+               while (!it.isEnd()) {
+                       nat |= _func(it);
+                       ++it;
+               }
+               result = nat;
+       }
+       return 0;
+}
+
+int TimeStampF1D::operator()(Interface1D& inter)
+{
+       TimeStamp *timestamp = TimeStamp::instance();
+       inter.setTimeStamp(timestamp->getTimeStamp());
+       return 0;
+}
+
+int ChainingTimeStampF1D::operator()(Interface1D& inter)
+{
+       TimeStamp *timestamp = TimeStamp::instance();
+       ViewEdge *ve = dynamic_cast<ViewEdge*>(&inter);
+       if (ve)
+               ve->setChainingTimeStamp(timestamp->getTimeStamp());
+       return 0;
+}
+
+int IncrementChainingTimeStampF1D::operator()(Interface1D& inter)
+{
+       ViewEdge *ve = dynamic_cast<ViewEdge*>(&inter);
+       if (ve)
+               ve->setChainingTimeStamp(ve->getChainingTimeStamp()+1);
+       return 0;
+}
+
+int GetShapeF1D::operator()(Interface1D& inter)
+{
+       vector<ViewShape*> shapesVector;
+       set<ViewShape*> shapesSet;
+       ViewEdge *ve = dynamic_cast<ViewEdge*>(&inter);
+       if (ve) {
+               shapesVector.push_back(ve->viewShape());
+       }
+       else {
+               Interface0DIterator it = inter.verticesBegin(), itend = inter.verticesEnd();
+               for (; it != itend; ++it)
+                       shapesSet.insert(Functions0D::getShapeF0D(it));
+               shapesVector.insert<set<ViewShape*>::iterator>(shapesVector.begin(), shapesSet.begin(), shapesSet.end());
+       }
+       result = shapesVector;
+       return 0;
+}
+
+int GetOccludersF1D::operator()(Interface1D& inter)
+{
+       vector<ViewShape*> shapesVector;
+       set<ViewShape*> shapesSet;
+       ViewEdge *ve = dynamic_cast<ViewEdge*>(&inter);
+       if (ve) {
+               result = ve->occluders();
+       }
+       else {
+               Interface0DIterator it = inter.verticesBegin(), itend = inter.verticesEnd();
+               for (; it != itend; ++it) {
+                       Functions0D::getOccludersF0D(it, shapesSet);
+               }
+               shapesVector.insert(shapesVector.begin(), shapesSet.begin(), shapesSet.end());
+               result = shapesVector;
+       }
+       return 0;
+}
+
+int GetOccludeeF1D::operator()(Interface1D& inter)
+{
+       vector<ViewShape*> shapesVector;
+       set<ViewShape*> shapesSet;
+       ViewEdge *ve = dynamic_cast<ViewEdge*>(&inter);
+       if (ve) {
+               ViewShape *aShape = ve->aShape();
+               shapesVector.push_back(aShape);
+       }
+       else {
+               Interface0DIterator it = inter.verticesBegin(), itend = inter.verticesEnd();
+               for (; it != itend; ++it) {
+                       shapesSet.insert(Functions0D::getOccludeeF0D(it));
+               }
+               shapesVector.insert<set<ViewShape*>::iterator>(shapesVector.begin(), shapesSet.begin(), shapesSet.end());
+       }
+       result = shapesVector;
+       return 0;
+}
+
+// Internal
+////////////
+
+void getOccludeeF1D(Interface1D& inter, set<ViewShape*>& oShapes)
+{
+       ViewEdge *ve = dynamic_cast<ViewEdge*>(&inter);
+       if (ve) {
+               ViewShape *aShape = ve->aShape();
+               if (aShape == 0) {
+                       oShapes.insert(0);
+                       return;
+               }
+               oShapes.insert(aShape);
+       }
+       else {
+               Interface0DIterator it = inter.verticesBegin(), itend = inter.verticesEnd();
+               for (; it != itend; ++it)
+                       oShapes.insert(Functions0D::getOccludeeF0D(it));
+       }
+}
+
+void getOccludersF1D(Interface1D& inter, set<ViewShape*>& oShapes)
+{
+       ViewEdge *ve = dynamic_cast<ViewEdge*>(&inter);
+       if (ve) {
+               vector<ViewShape*>& occluders = ve->occluders();
+               oShapes.insert<vector<ViewShape*>::iterator>(occluders.begin(), occluders.end());
+       }
+       else {
+               Interface0DIterator it = inter.verticesBegin(), itend = inter.verticesEnd();
+               for (; it != itend; ++it) {
+                       set<ViewShape*> shapes;
+                       Functions0D::getOccludersF0D(it, shapes);
+                       for (set<ViewShape*>::iterator s = shapes.begin(), send = shapes.end(); s != send; ++s)
+                               oShapes.insert(*s);
+               }
+       }
+}
+
+void getShapeF1D(Interface1D& inter, set<ViewShape*>& oShapes)
+{
+       ViewEdge *ve = dynamic_cast<ViewEdge*>(&inter);
+       if (ve) {
+               oShapes.insert(ve->viewShape());
+       }
+       else {
+               Interface0DIterator it = inter.verticesBegin(), itend = inter.verticesEnd();
+               for (; it != itend; ++it)
+                       oShapes.insert(Functions0D::getShapeF0D(it));
+       }
+}
+
 } // end of namespace Functions1D
index ba42b25b47ea115e62b16b3da6d8e488b5790318..f1885aa1762129240e10b6f4f1f6c1f8aff7640f 100644 (file)
@@ -1,41 +1,48 @@
-//
-//  Filename         : Functions1D.h
-//  Author(s)        : Stephane Grabli, Emmanuel Turquin
-//  Purpose          : Functions taking 1D input
-//  Date of creation : 01/07/2003
-//
-///////////////////////////////////////////////////////////////////////////////
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) 2010 Blender Foundation.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
 
+#ifndef __FREESTYLE_FUNCTIONS_1D_H__
+#define __FREESTYLE_FUNCTIONS_1D_H__
 
-//
-//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
-//   with this source distribution. 
-//
-//  This program is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU General Public License
-//  as published by the Free Software Foundation; either version 2
-//  of the License, or (at your option) any later version.
-//
-//  This program is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//  GNU General Public License for more details.
-//
-//  You should have received a copy of the GNU General Public License
-//  along with this program; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
-//
-///////////////////////////////////////////////////////////////////////////////
+/** \file blender/freestyle/intern/view_map/Functions1D.h
+ *  \ingroup freestyle
+ *  \brief Functions taking 1D input
+ *  \author Stephane Grabli
+ *  \author Emmanuel Turquin
+ *  \date 01/07/2003
+ */
 
-#ifndef  FUNCTIONS1D_HPP
-# define FUNCTIONS1D_HPP
+#include "Functions0D.h"
+#include "Interface1D.h"
+#include "ViewMap.h"
 
-# include "ViewMap.h"
-# include "Functions0D.h"
-# include "Interface1D.h"
-# include "../system/Precision.h"
-# include "../system/TimeStamp.h"
-# include "../system/FreestyleConfig.h"
+#include "../system/FreestyleConfig.h"
+#include "../system/Precision.h"
+#include "../system/TimeStamp.h"
 
 #include "../python/Director.h"
 
 //
 ///////////////////////////////////////////////////////////
 
-/*! Base class for Unary Functions (functors) working
- *  on Interface1D.
- *  A unary function will be used by calling
- *  its operator() on an Interface1D.
- *  \attention In the scripting language, there exists
- *  several prototypes depending on the returned value type.
- *  For example, you would inherit from a UnaryFunction1DDouble
- *  if you wish to define a function that returns a double.
+/*! Base class for Unary Functions (functors) working on Interface1D.
+ *  A unary function will be used by calling its operator() on an Interface1D.
+ *  \attention In the scripting language, there exists several prototypes depending on the returned value type.
+ *  For example, you would inherit from a UnaryFunction1DDouble if you wish to define a function that returns a double.
  *  The different existing prototypes are:
  *    - UnaryFunction1DVoid
  *    - UnaryFunction1DUnsigned
@@ -65,81 +68,104 @@ template <class T>
 class /*LIB_VIEW_MAP_EXPORT*/ UnaryFunction1D
 {
 public:
-
        T result;
        PyObject *py_uf1D;
 
-  /*! The type of the value
-   *  returned by the functor.
-   */
-  typedef T ReturnedValueType;
-  
-  /*! Default constructor */
-  UnaryFunction1D(){_integration = MEAN;}
-  /*! Builds a UnaryFunction1D from an integration type.
-   *  \param iType
-   *    In case the result for the Interface1D would be
-   *    obtained by evaluating a 0D function over the different
-   *    Interface0D of the Interface1D, \a iType tells which
-   *    integration method to use.
-   *    The default integration method is the MEAN.
-   */
-  UnaryFunction1D(IntegrationType iType){_integration = iType;}
-  /*! destructor. */
-  virtual ~UnaryFunction1D() {}
-
-  /*! returns the string "UnaryFunction1D". */
-  virtual string getName() const {
-    return "UnaryFunction1D";
-  }
-  /*! The operator ().
-   *  \param inter 
-   *    The Interface1D on which we wish to evaluate
-   *    the function.
-   *  \return the result of the function of type T.
-   */
-  virtual int operator()(Interface1D& inter) {
-       return Director_BPy_UnaryFunction1D___call__( this, py_uf1D, inter );
-  }
-       
-  /*! Sets the integration method */
-  void setIntegrationType(IntegrationType integration) {
-    _integration = integration;
-  }
-  /*! Returns the integration method. */
-  IntegrationType getIntegrationType() const {
-    return _integration;
-  }
+       /*! The type of the value returned by the functor. */
+       typedef T ReturnedValueType;
 
-protected:
+       /*! Default constructor */
+       UnaryFunction1D()
+       {
+               _integration = MEAN;
+       }
+
+       /*! Builds a UnaryFunction1D from an integration type.
+        *  \param iType
+        *    In case the result for the Interface1D would be obtained by evaluating a 0D function over the different
+        *    Interface0D of the Interface1D, \a iType tells which integration method to use.
+        *    The default integration method is the MEAN.
+        */
+       UnaryFunction1D(IntegrationType iType)
+       {
+               _integration = iType;
+       }
+
+       /*! destructor. */
+       virtual ~UnaryFunction1D() {}
+
+       /*! returns the string "UnaryFunction1D". */
+       virtual string getName() const
+       {
+               return "UnaryFunction1D";
+       }
+
+       /*! The operator ().
+        *  \param inter 
+        *    The Interface1D on which we wish to evaluate the function.
+        *  \return the result of the function of type T.
+        */
+       virtual int operator()(Interface1D& inter)
+       {
+               return Director_BPy_UnaryFunction1D___call__(this, py_uf1D, inter);
+       }
+
+       /*! Sets the integration method */
+       void setIntegrationType(IntegrationType integration)
+       {
+               _integration = integration;
+       }
+
+       /*! Returns the integration method. */
+       IntegrationType getIntegrationType() const
+       {
+               return _integration;
+       }
 
-  IntegrationType _integration;
+protected:
+       IntegrationType _integration;
 };
 
 
 class  UnaryFunction1D_void
 {
 public:
-
        PyObject *py_uf1D;
 
-       UnaryFunction1D_void(){_integration = MEAN;}
-       UnaryFunction1D_void(IntegrationType iType){_integration = iType;}
+       UnaryFunction1D_void()
+       {
+               _integration = MEAN;
+       }
+
+       UnaryFunction1D_void(IntegrationType iType)
+       {
+               _integration = iType;
+       }
+
        virtual ~UnaryFunction1D_void() {}
-       
-       virtual string getName() const {
+
+       virtual string getName() const
+       {
                return "UnaryFunction1D_void";
        }
-       
-       int operator()(Interface1D& inter) {
-               return Director_BPy_UnaryFunction1D___call__( this, py_uf1D, inter );
+
+       int operator()(Interface1D& inter)
+       {
+               return Director_BPy_UnaryFunction1D___call__(this, py_uf1D, inter);
+       }
+
+       void setIntegrationType(IntegrationType integration)
+       {
+               _integration = integration;
+       }
+
+       IntegrationType getIntegrationType() const
+       {
+               return _integration;
        }
-       
-       void setIntegrationType(IntegrationType integration) { _integration = integration; }
-       IntegrationType getIntegrationType() const { return _integration; }
-       
-       protected:
-               IntegrationType _integration;
+
+protected:
+       IntegrationType _integration;
 };
 
 
@@ -150,406 +176,452 @@ public:
 
 namespace Functions1D {
 
-  // GetXF1D
-  /*! Returns the X 3D coordinate of an Interface1D. */
-  class LIB_VIEW_MAP_EXPORT GetXF1D : public UnaryFunction1D<real>
-  {
-  private:
-    Functions0D::GetXF0D _func;
-  public:
-    /*! Builds the functor.
-     *  \param iType
-     *    The integration method used to compute
-     *    a single value from a set of values.
-     */
-    GetXF1D(IntegrationType iType) : UnaryFunction1D<real>(iType){}
-    /*! Returns the string "GetXF1D"*/
-    string getName() const {
-      return "GetXF1D";
-    }
-    /*! the () operator.*/
-    int operator()(Interface1D& inter) ;
-  };
-
-  // GetYF1D
-  /*! Returns the Y 3D coordinate of an Interface1D. */
-  class LIB_VIEW_MAP_EXPORT GetYF1D : public UnaryFunction1D<real>
-  {
-  private:
-    Functions0D::GetYF0D _func;
-  public:
-    /*! Builds the functor.
-     *  \param iType
-     *    The integration method used to compute
-     *    a single value from a set of values.
-     */
-    GetYF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(iType){}
-    /*! Returns the string "GetYF1D"*/
-    string getName() const {
-      return "GetYF1D";
-    }
-    /*! the () operator.*/
-    int operator()(Interface1D& inter) ;
-  };
-
-  // GetZF1D
-  /*! Returns the Z 3D coordinate of an Interface1D. */
-  class LIB_VIEW_MAP_EXPORT GetZF1D : public UnaryFunction1D<real>
-  {
-  private:
-    Functions0D::GetZF0D _func;
-  public:
-    /*! Builds the functor.
-     *  \param iType
-     *    The integration method used to compute
-     *    a single value from a set of values.
-     */
-    GetZF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(iType){}
-    /*! Returns the string "GetZF1D"*/
-    string getName() const {
-      return "GetZF1D";
-    }
-    /*! the () operator.*/
-    int operator()(Interface1D& inter) ;
-  };
-
-  // GetProjectedXF1D
-  /*! Returns the projected X 3D coordinate of an Interface1D. */
-  class LIB_VIEW_MAP_EXPORT GetProjectedXF1D : public UnaryFunction1D<real>
-  {
-  private:
-    Functions0D::GetProjectedXF0D _func;
-  public:
-    /*! Builds the functor.
-     *  \param iType
-     *    The integration method used to compute
-     *    a single value from a set of values.
-     */
-    GetProjectedXF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(iType){}
-  public:
-    /*! Returns the string "GetProjectedXF1D"*/
-    string getName() const {
-      return "GetProjectedXF1D";
-    }
-    /*! the () operator.*/
-    int operator()(Interface1D& inter);
-  };
-  
-  // GetProjectedYF1D
-  /*! Returns the projected Y 3D coordinate of an Interface1D. */
-  class LIB_VIEW_MAP_EXPORT GetProjectedYF1D : public UnaryFunction1D<real>
-  {
-  private:
-    Functions0D::GetProjectedYF0D _func;
-  public:
-    /*! Builds the functor.
-     *  \param iType
-     *    The integration method used to compute
-     *    a single value from a set of values.
-     */
-    GetProjectedYF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(iType){}
-  public:
-    /*! Returns the string "GetProjectedYF1D"*/
-    string getName() const {
-      return "GetProjectedYF1D";
-    }
-    /*! the () operator.*/
-    int operator()(Interface1D& inter);
-  };
-
-  // GetProjectedZF1D
-  /*! Returns the projected Z 3D coordinate of an Interface1D. */
-  class LIB_VIEW_MAP_EXPORT GetProjectedZF1D : public UnaryFunction1D<real>
-  {
-  private:
-    Functions0D::GetProjectedZF0D _func;
-  public:
-    /*! Builds the functor.
-     *  \param iType
-     *    The integration method used to compute
-     *    a single value from a set of values.
-     */
-    GetProjectedZF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(iType){}
-  public:
-    /*! Returns the string "GetProjectedZF1D"*/
-    string getName() const {
-      return "GetProjectedZF1D";
-    }
-    /*! the () operator.*/
-    int operator()(Interface1D& inter);
-  };
-  
-  // Orientation2DF1D
-  /*! Returns the 2D orientation as a Vec2f*/
-  class LIB_VIEW_MAP_EXPORT Orientation2DF1D : public UnaryFunction1D<Vec2f>
-  {
-  private:
-    Functions0D::VertexOrientation2DF0D _func;
-  public:
-    /*! Builds the functor.
-     *  \param iType
-     *    The integration method used to compute
-     *    a single value from a set of values.
-     */
-    Orientation2DF1D(IntegrationType iType = MEAN) : UnaryFunction1D<Vec2f>(iType){}
-    /*! Returns the string "Orientation2DF1D"*/
-    string getName() const {
-      return "Orientation2DF1D";
-    }
-    /*! the () operator.*/
-    int operator()(Interface1D& inter);
-  };
-
-  // Orientation3DF1D
-  /*! Returns the 3D orientation as a Vec3f. */
-  class LIB_VIEW_MAP_EXPORT Orientation3DF1D : public UnaryFunction1D<Vec3f>
-  {
-  private:
-    Functions0D::VertexOrientation3DF0D _func;
-  public:
-    /*! Builds the functor.
-     *  \param iType
-     *    The integration method used to compute
-     *    a single value from a set of values.
-     */
-    Orientation3DF1D(IntegrationType iType = MEAN) : UnaryFunction1D<Vec3f>(iType){}
-    /*! Returns the string "Orientation3DF1D"*/
-    string getName() const {
-      return "Orientation3DF1D";
-    }
-    /*! the () operator.*/    
-    int operator()(Interface1D& inter);
-  };
-
-  // ZDiscontinuityF1D
-  /*! Returns a real giving the distance between
-   *  and Interface1D and the shape that lies behind (occludee).
-   *  This distance is evaluated in the camera space and normalized
-   *  between 0 and 1. Therefore, if no oject is occluded by the
-   *  shape to which the Interface1D belongs to, 1 is returned.
-   */
-  class LIB_VIEW_MAP_EXPORT ZDiscontinuityF1D : public UnaryFunction1D<real>
-  {
-  private:
-    Functions0D::ZDiscontinuityF0D _func;
-  public:
-    /*! Builds the functor.
-     *  \param iType
-     *    The integration method used to compute
-     *    a single value from a set of values.
-     */
-    ZDiscontinuityF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(iType){}
-    /*! Returns the string "ZDiscontinuityF1D"*/
-    string getName() const {
-      return "ZDiscontinuityF1D";
-    }
-    /*! the () operator.*/        
-    int operator()(Interface1D& inter);
-  };
-  
-  // QuantitativeInvisibilityF1D
-  /*! Returns the Quantitative Invisibility of an Interface1D element.
-   *  If the Interface1D is a ViewEdge, then there is no ambiguity
-   *  concerning the result. But, if the Interface1D results of a chaining
-   *  (chain, stroke), then it might be made of several 1D elements
-   *  of different Quantitative Invisibilities.
-   */
-  class LIB_VIEW_MAP_EXPORT QuantitativeInvisibilityF1D : public UnaryFunction1D<unsigned>
-  {
-  private:
-    Functions0D::QuantitativeInvisibilityF0D _func;
-  public:
-  /*! Builds the functor.
-     *  \param iType
-     *    The integration method used to compute
-     *    a single value from a set of values.
-     */
-    QuantitativeInvisibilityF1D(IntegrationType iType = MEAN) : UnaryFunction1D<unsigned int>(iType) {}
-   /*! Returns the string "QuantitativeInvisibilityF1D"*/
-    string getName() const {
-      return "QuantitativeInvisibilityF1D";
-    }
-  /*! the () operator.*/        
-    int operator()(Interface1D& inter);
-  };
-
-  // CurveNatureF1D
+// GetXF1D
+/*! Returns the X 3D coordinate of an Interface1D. */
+class LIB_VIEW_MAP_EXPORT GetXF1D : public UnaryFunction1D<real>
+{
+private:
+       Functions0D::GetXF0D _func;
+
+public:
+       /*! Builds the functor.
+        *  \param iType
+        *    The integration method used to compute a single value from a set of values.
+        */
+       GetXF1D(IntegrationType iType) : UnaryFunction1D<real>(iType) {}
+
+       /*! Returns the string "GetXF1D" */
+       string getName() const
+       {
+               return "GetXF1D";
+       }
+
+       /*! the () operator. */
+       int operator()(Interface1D& inter);
+};
+
+// GetYF1D
+/*! Returns the Y 3D coordinate of an Interface1D. */
+class LIB_VIEW_MAP_EXPORT GetYF1D : public UnaryFunction1D<real>
+{
+private:
+Functions0D::GetYF0D _func;
+
+public:
+       /*! Builds the functor.
+        *  \param iType
+        *    The integration method used to compute a single value from a set of values.
+        */
+       GetYF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(iType) {}
+
+       /*! Returns the string "GetYF1D" */
+       string getName() const
+       {
+               return "GetYF1D";
+       }
+
+       /*! the () operator. */
+       int operator()(Interface1D& inter);
+};
+
+// GetZF1D
+/*! Returns the Z 3D coordinate of an Interface1D. */
+class LIB_VIEW_MAP_EXPORT GetZF1D : public UnaryFunction1D<real>
+{
+private:
+       Functions0D::GetZF0D _func;
+
+public:
+       /*! Builds the functor.
+        *  \param iType
+        *    The integration method used to compute a single value from a set of values.
+        */
+       GetZF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(iType) {}
+
+       /*! Returns the string "GetZF1D" */
+       string getName() const
+       {
+               return "GetZF1D";
+       }
+
+       /*! the () operator. */
+       int operator()(Interface1D& inter);
+};
+
+// GetProjectedXF1D
+/*! Returns the projected X 3D coordinate of an Interface1D. */
+class LIB_VIEW_MAP_EXPORT GetProjectedXF1D : public UnaryFunction1D<real>
+{
+private:
+       Functions0D::GetProjectedXF0D _func;
+
+public:
+       /*! Builds the functor.
+        *  \param iType
+        *    The integration method used to compute a single value from a set of values.
+        */
+       GetProjectedXF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(iType) {}
+
+       /*! Returns the string "GetProjectedXF1D" */
+       string getName() const
+       {
+               return "GetProjectedXF1D";
+       }
+
+       /*! the () operator. */
+       int operator()(Interface1D& inter);
+};
+
+// GetProjectedYF1D
+/*! Returns the projected Y 3D coordinate of an Interface1D. */
+class LIB_VIEW_MAP_EXPORT GetProjectedYF1D : public UnaryFunction1D<real>
+{
+private:
+       Functions0D::GetProjectedYF0D _func;
+
+public:
+       /*! Builds the functor.
+        *  \param iType
+        *    The integration method used to compute a single value from a set of values.
+        */
+       GetProjectedYF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(iType) {}
+
+       /*! Returns the string "GetProjectedYF1D" */
+       string getName() const
+       {
+               return "GetProjectedYF1D";
+       }
+
+       /*! the () operator. */
+       int operator()(Interface1D& inter);
+};
+
+// GetProjectedZF1D
+/*! Returns the projected Z 3D coordinate of an Interface1D. */
+class LIB_VIEW_MAP_EXPORT GetProjectedZF1D : public UnaryFunction1D<real>
+{
+private:
+       Functions0D::GetProjectedZF0D _func;
+
+public:
+       /*! Builds the functor.
+        *  \param iType
+        *    The integration method used to compute a single value from a set of values.
+        */
+       GetProjectedZF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(iType) {}
+
+       /*! Returns the string "GetProjectedZF1D" */
+       string getName() const
+       {
+               return "GetProjectedZF1D";
+       }
+
+       /*! the () operator. */
+       int operator()(Interface1D& inter);
+};
+
+// Orientation2DF1D
+/*! Returns the 2D orientation as a Vec2f*/
+class LIB_VIEW_MAP_EXPORT Orientation2DF1D : public UnaryFunction1D<Vec2f>
+{
+private:
+       Functions0D::VertexOrientation2DF0D _func;
+
+public:
+       /*! Builds the functor.
+        *  \param iType
+        *    The integration method used to compute a single value from a set of values.
+        */
+       Orientation2DF1D(IntegrationType iType = MEAN) : UnaryFunction1D<Vec2f>(iType) {}
+
+       /*! Returns the string "Orientation2DF1D" */
+       string getName() const
+       {
+               return "Orientation2DF1D";
+       }
+
+       /*! the () operator. */
+       int operator()(Interface1D& inter);
+};
+
+// Orientation3DF1D
+/*! Returns the 3D orientation as a Vec3f. */
+class LIB_VIEW_MAP_EXPORT Orientation3DF1D : public UnaryFunction1D<Vec3f>
+{
+private:
+       Functions0D::VertexOrientation3DF0D _func;
+
+public:
+       /*! Builds the functor.
+        *  \param iType
+        *    The integration method used to compute a single value from a set of values.
+        */
+       Orientation3DF1D(IntegrationType iType = MEAN) : UnaryFunction1D<Vec3f>(iType) {}
+
+       /*! Returns the string "Orientation3DF1D" */
+       string getName() const
+       {
+               return "Orientation3DF1D";
+       }
+
+       /*! the () operator. */
+       int operator()(Interface1D& inter);
+};
+
+// ZDiscontinuityF1D
+/*! Returns a real giving the distance between and Interface1D and the shape that lies behind (occludee).
+ *  This distance is evaluated in the camera space and normalized between 0 and 1. Therefore, if no oject is occluded
+ *  by the shape to which the Interface1D belongs to, 1 is returned.
+ */
+class LIB_VIEW_MAP_EXPORT ZDiscontinuityF1D : public UnaryFunction1D<real>
+{
+private:
+       Functions0D::ZDiscontinuityF0D _func;
+
+public:
+       /*! Builds the functor.
+        *  \param iType
+        *    The integration method used to compute a single value from a set of values.
+        */
+       ZDiscontinuityF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(iType) {}
+
+       /*! Returns the string "ZDiscontinuityF1D" */
+       string getName() const
+       {
+               return "ZDiscontinuityF1D";
+       }
+
+       /*! the () operator. */
+       int operator()(Interface1D& inter);
+};
+
+// QuantitativeInvisibilityF1D
+/*! Returns the Quantitative Invisibility of an Interface1D element.
+ *  If the Interface1D is a ViewEdge, then there is no ambiguity concerning the result. But, if the Interface1D
+ *  results of a chaining (chain, stroke), then it might be made of several 1D elements of different
+ *  Quantitative Invisibilities.
+ */
+class LIB_VIEW_MAP_EXPORT QuantitativeInvisibilityF1D : public UnaryFunction1D<unsigned>
+{
+private:
+       Functions0D::QuantitativeInvisibilityF0D _func;
+
+public:
+       /*! Builds the functor.
+        *  \param iType
+        *    The integration method used to compute a single value from a set of values.
+        */
+       QuantitativeInvisibilityF1D(IntegrationType iType = MEAN) : UnaryFunction1D<unsigned int>(iType) {}
+
+       /*! Returns the string "QuantitativeInvisibilityF1D" */
+       string getName() const
+       {
+               return "QuantitativeInvisibilityF1D";
+       }
+
+       /*! the () operator. */
+       int operator()(Interface1D& inter);
+};
+
+// CurveNatureF1D
 /*! Returns the nature of the Interface1D (silhouette, ridge, crease...).
  *  Except if the Interface1D is a ViewEdge, this result might be ambiguous.
- *  Indeed, the Interface1D might result from the gathering of several 1D elements,
- *  each one being of a different nature. An integration method, such as
- *  the MEAN, might give, in this case, irrelevant results.
+ *  Indeed, the Interface1D might result from the gathering of several 1D elements, each one being of a different
+ *  nature. An integration method, such as the MEAN, might give, in this case, irrelevant results.
  */
-  class LIB_VIEW_MAP_EXPORT CurveNatureF1D : public UnaryFunction1D<Nature::EdgeNature>
-  {
-  private:
-    Functions0D::CurveNatureF0D _func;
-  public:
-    /*! Builds the functor.
-     *  \param iType
-     *    The integration method used to compute
-     *    a single value from a set of values.
-     */
-    CurveNatureF1D(IntegrationType iType = MEAN) : UnaryFunction1D<Nature::EdgeNature>(iType) {}
-    /*! Returns the string "CurveNatureF1D"*/
-    string getName() const {
-      return "CurveNatureF1D";
-    }
-    /*! the () operator.*/        
-    int operator()(Interface1D& inter);
-  };
-
-  // TimeStampF1D
+class LIB_VIEW_MAP_EXPORT CurveNatureF1D : public UnaryFunction1D<Nature::EdgeNature>
+{
+private:
+       Functions0D::CurveNatureF0D _func;
+
+public:
+       /*! Builds the functor.
+        *  \param iType
+        *    The integration method used to compute a single value from a set of values.
+        */
+       CurveNatureF1D(IntegrationType iType = MEAN) : UnaryFunction1D<Nature::EdgeNature>(iType) {}
+
+       /*! Returns the string "CurveNatureF1D" */
+       string getName() const
+       {
+               return "CurveNatureF1D";
+       }
+
+       /*! the () operator. */
+       int operator()(Interface1D& inter);
+};
+
+// TimeStampF1D
 /*! Returns the time stamp of the Interface1D. */
-  class LIB_VIEW_MAP_EXPORT TimeStampF1D : public UnaryFunction1D_void
-  {
-  public:
-    /*! Returns the string "TimeStampF1D"*/
-    string getName() const {
-      return "TimeStampF1D";
-    }
-    /*! the () operator.*/        
-    int operator()(Interface1D& inter);
-  };
-
-  // IncrementChainingTimeStampF1D
+class LIB_VIEW_MAP_EXPORT TimeStampF1D : public UnaryFunction1D_void
+{
+public:
+       /*! Returns the string "TimeStampF1D" */
+       string getName() const
+       {
+               return "TimeStampF1D";
+       }
+
+       /*! the () operator. */
+       int operator()(Interface1D& inter);
+};
+
+// IncrementChainingTimeStampF1D
 /*! Increments the chaining time stamp of the Interface1D. */
-  class LIB_VIEW_MAP_EXPORT IncrementChainingTimeStampF1D : public UnaryFunction1D_void
-  {
-  public:
-    /*! Returns the string "IncrementChainingTimeStampF1D"*/
-    string getName() const {
-      return "IncrementChainingTimeStampF1D";
-    }
-    /*! the () operator.*/        
-    int operator()(Interface1D& inter);
-  };
-
-  // ChainingTimeStampF1D
+class LIB_VIEW_MAP_EXPORT IncrementChainingTimeStampF1D : public UnaryFunction1D_void
+{
+public:
+       /*! Returns the string "IncrementChainingTimeStampF1D" */
+       string getName() const
+       {
+               return "IncrementChainingTimeStampF1D";
+       }
+
+       /*! the () operator. */
+       int operator()(Interface1D& inter);
+};
+
+// ChainingTimeStampF1D
 /*! Sets the chaining time stamp of the Interface1D. */
-  class LIB_VIEW_MAP_EXPORT ChainingTimeStampF1D : public UnaryFunction1D_void
-  {
-  public:
-    /*! Returns the string "ChainingTimeStampF1D"*/
-    string getName() const {
-      return "ChainingTimeStampF1D";
-    }
-    /*! the () operator.*/        
-    int operator()(Interface1D& inter);
-  };
-  
-
-  // Curvature2DAngleF1D
+class LIB_VIEW_MAP_EXPORT ChainingTimeStampF1D : public UnaryFunction1D_void
+{
+public:
+       /*! Returns the string "ChainingTimeStampF1D" */
+       string getName() const
+       {
+               return "ChainingTimeStampF1D";
+       }
+
+       /*! the () operator. */
+       int operator()(Interface1D& inter);
+};
+
+
+// Curvature2DAngleF1D
 /*! Returns the 2D curvature as an angle for an Interface1D. */
-  class LIB_VIEW_MAP_EXPORT Curvature2DAngleF1D : public UnaryFunction1D<real>
-  {
-  public:
-    /*! Builds the functor.
-     *  \param iType
-     *    The integration method used to compute
-     *    a single value from a set of values.
-     */
-    Curvature2DAngleF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(iType) {}
-    /*! Returns the string "Curvature2DAngleF1D"*/
-    string getName() const {
-      return "Curvature2DAngleF1D";
-    }
-    /*! the () operator.*/        
-    int operator()(Interface1D& inter) {
-      result = integrate(_fun, inter.verticesBegin(), inter.verticesEnd(), _integration);
-         return 0;
-    }
-  private:
-    Functions0D::Curvature2DAngleF0D   _fun;
-  };
-
-  // Normal2DF1D
-  /*! Returns the 2D normal for an interface 1D. */
-  class LIB_VIEW_MAP_EXPORT Normal2DF1D : public UnaryFunction1D<Vec2f>
-  {
-  public:
-    /*! Builds the functor.
-     *  \param iType
-     *    The integration method used to compute
-     *    a single value from a set of values.
-     */
-    Normal2DF1D(IntegrationType iType = MEAN) : UnaryFunction1D<Vec2f>(iType) {}
-    /*! Returns the string "Normal2DF1D"*/
-    string getName() const {
-      return "Normal2DF1D";
-    }
-    /*! the () operator.*/        
-    int operator()(Interface1D& inter) {
-      result = integrate(_fun, inter.verticesBegin(), inter.verticesEnd(), _integration);
-         return 0;
-    }
-  private:
-    Functions0D::Normal2DF0D   _fun;
-  };
-
-  // GetShapeF1D
-  /*! Returns list of shapes covered by this Interface1D. */
-  class LIB_VIEW_MAP_EXPORT GetShapeF1D : public UnaryFunction1D<std::vector<ViewShape*> >
-  {
-  public:
-    /*! Builds the functor.
-     */
-    GetShapeF1D() : UnaryFunction1D<std::vector<ViewShape*> >() {}
-    /*! Returns the string "GetShapeF1D"*/
-    string getName() const {
-      return "GetShapeF1D";
-    }
-    /*! the () operator.*/        
-    int operator()(Interface1D& inter);
-  };
-
-  // GetOccludersF1D
-  /*! Returns list of occluding shapes covered by this Interface1D. */
-  class LIB_VIEW_MAP_EXPORT GetOccludersF1D : public UnaryFunction1D<std::vector<ViewShape*> >
-  {
-  public:
-    /*! Builds the functor.
-     */
-    GetOccludersF1D() : UnaryFunction1D<std::vector<ViewShape*> >() {}
-    /*! Returns the string "GetOccludersF1D"*/
-    string getName() const {
-      return "GetOccludersF1D";
-    }
-    /*! the () operator.*/        
-    int operator()(Interface1D& inter);
-  };
-
-  // GetOccludeeF1D
-  /*! Returns list of occluded shapes covered by this Interface1D. */
-  class LIB_VIEW_MAP_EXPORT GetOccludeeF1D : public UnaryFunction1D<std::vector<ViewShape*> >
-  {
-  public:
-    /*! Builds the functor.
-     */
-    GetOccludeeF1D() : UnaryFunction1D<std::vector<ViewShape*> >() {}
-    /*! Returns the string "GetOccludeeF1D"*/
-    string getName() const {
-      return "GetOccludeeF1D";
-    }
-    /*! the () operator.*/        
-    int operator()(Interface1D& inter);
-  };
-
-  // internal
-  ////////////
-
-  // getOccludeeF1D
-  LIB_VIEW_MAP_EXPORT
-  void getOccludeeF1D(Interface1D& inter, set<ViewShape*>& oShapes);
-
-  // getOccludersF1D
-  LIB_VIEW_MAP_EXPORT
-  void getOccludersF1D(Interface1D& inter, set<ViewShape*>& oShapes);
-
-  // getShapeF1D
-  LIB_VIEW_MAP_EXPORT
-  void getShapeF1D(Interface1D& inter, set<ViewShape*>& oShapes);
-  
+class LIB_VIEW_MAP_EXPORT Curvature2DAngleF1D : public UnaryFunction1D<real>
+{
+public:
+       /*! Builds the functor.
+        *  \param iType
+        *    The integration method used to compute a single value from a set of values.
+        */
+       Curvature2DAngleF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(iType) {}
+
+       /*! Returns the string "Curvature2DAngleF1D" */
+       string getName() const
+       {
+               return "Curvature2DAngleF1D";
+       }
+
+       /*! the () operator.*/
+       int operator()(Interface1D& inter)
+       {
+               result = integrate(_fun, inter.verticesBegin(), inter.verticesEnd(), _integration);
+               return 0;
+       }
+
+private:
+       Functions0D::Curvature2DAngleF0D _fun;
+};
+
+// Normal2DF1D
+/*! Returns the 2D normal for an interface 1D. */
+class LIB_VIEW_MAP_EXPORT Normal2DF1D : public UnaryFunction1D<Vec2f>
+{
+public:
+       /*! Builds the functor.
+        *  \param iType
+        *    The integration method used to compute a single value from a set of values.
+        */
+       Normal2DF1D(IntegrationType iType = MEAN) : UnaryFunction1D<Vec2f>(iType) {}
+
+       /*! Returns the string "Normal2DF1D" */
+       string getName() const
+       {
+               return "Normal2DF1D";
+       }
+
+       /*! the () operator.*/
+       int operator()(Interface1D& inter)
+       {
+               result = integrate(_fun, inter.verticesBegin(), inter.verticesEnd(), _integration);
+               return 0;
+       }
+
+private:
+       Functions0D::Normal2DF0D _fun;
+};
+
+// GetShapeF1D
+/*! Returns list of shapes covered by this Interface1D. */
+class LIB_VIEW_MAP_EXPORT GetShapeF1D : public UnaryFunction1D<std::vector<ViewShape*> >
+{
+public:
+       /*! Builds the functor. */
+       GetShapeF1D() : UnaryFunction1D<std::vector<ViewShape*> >() {}
+
+       /*! Returns the string "GetShapeF1D" */
+       string getName() const
+       {
+               return "GetShapeF1D";
+       }
+
+       /*! the () operator. */
+       int operator()(Interface1D& inter);
+};
+
+// GetOccludersF1D
+/*! Returns list of occluding shapes covered by this Interface1D. */
+class LIB_VIEW_MAP_EXPORT GetOccludersF1D : public UnaryFunction1D<std::vector<ViewShape*> >
+{
+public:
+       /*! Builds the functor. */
+       GetOccludersF1D() : UnaryFunction1D<std::vector<ViewShape*> >() {}
+
+       /*! Returns the string "GetOccludersF1D" */
+       string getName() const
+       {
+               return "GetOccludersF1D";
+       }
+
+       /*! the () operator. */
+       int operator()(Interface1D& inter);
+};
+
+// GetOccludeeF1D
+/*! Returns list of occluded shapes covered by this Interface1D. */
+class LIB_VIEW_MAP_EXPORT GetOccludeeF1D : public UnaryFunction1D<std::vector<ViewShape*> >
+{
+public:
+       /*! Builds the functor. */
+       GetOccludeeF1D() : UnaryFunction1D<std::vector<ViewShape*> >() {}
+
+       /*! Returns the string "GetOccludeeF1D" */
+       string getName() const
+       {
+               return "GetOccludeeF1D";
+       }
+
+       /*! the () operator. */
+       int operator()(Interface1D& inter);
+};
+
+// internal
+////////////
+
+// getOccludeeF1D
+LIB_VIEW_MAP_EXPORT
+void getOccludeeF1D(Interface1D& inter, set<ViewShape*>& oShapes);
+
+// getOccludersF1D
+LIB_VIEW_MAP_EXPORT
+void getOccludersF1D(Interface1D& inter, set<ViewShape*>& oShapes);
+
+// getShapeF1D
+LIB_VIEW_MAP_EXPORT
+void getShapeF1D(Interface1D& inter, set<ViewShape*>& oShapes);
+
 } // end of namespace Functions1D
 
-#endif // FUNCTIONS1D_HPP
+#endif // __FREESTYLE_FUNCTIONS_1D_H__
index 078fc5f2c9807a52c153765429f0182f480d82a9..cc711fedecef19a41b565a7fc266a7324e8b71a0 100644 (file)
-//
-//  Filename         : GridDensityProvider.h
-//  Author(s)        : Alexander Beels
-//  Purpose          : Class to define a cell grid surrounding
-//                     the projected image of a scene
-//  Date of creation : 2011-2-5
-//
-///////////////////////////////////////////////////////////////////////////////
-
-
-//
-//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
-//   with this source distribution. 
-//
-//  This program is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU General Public License
-//  as published by the Free Software Foundation; either version 2
-//  of the License, or (at your option) any later version.
-//
-//  This program is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//  GNU General Public License for more details.
-//
-//  You should have received a copy of the GNU General Public License
-//  along with this program; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef GRIDDENSITYPROVIDER_H
-#define GRIDDENSITYPROVIDER_H
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) 2010 Blender Foundation.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#ifndef __FREESTYLE_GRID_DENSITY_PROVIDER_H__
+#define __FREESTYLE_GRID_DENSITY_PROVIDER_H__
+
+/** \file blender/freestyle/intern/view_map/GridDensityProvider.h
+ *  \ingroup freestyle
+ *  \brief Class to define a cell grid surrounding the projected image of a scene
+ *  \author Alexander Beels
+ *  \date 2011-2-5
+ */
 
 #include <stdexcept>
 #include <memory>
+
 #include "OccluderSource.h"
+
 #include "../geometry/BBox.h"
 
-class GridDensityProvider {
+class GridDensityProvider
+{
        // Disallow copying and assignment
-       GridDensityProvider (const GridDensityProvider& other);
-       GridDensityProvider& operator= (const GridDensityProvider& other);
+       GridDensityProvider(const GridDensityProvider& other);
+       GridDensityProvider& operator=(const GridDensityProvider& other);
 
 public:
-       GridDensityProvider (OccluderSource& source)
-               : source(source) {
-       }
+       GridDensityProvider(OccluderSource& source) : source(source) {}
 
        virtual ~GridDensityProvider() {};
 
-       float cellSize() {
+       float cellSize()
+       {
                return _cellSize;
        }
 
-       unsigned cellsX() {
+       unsigned cellsX()
+       {
                return _cellsX;
        }
 
-       unsigned cellsY() {
+       unsigned cellsY()
+       {
                return _cellsY;
        }
 
-       float cellOrigin(int index) {
-               if ( index < 2 ) {
+       float cellOrigin(int index)
+       {
+               if (index < 2) {
                        return _cellOrigin[index];
-               } else {
+               }
+               else {
                        throw new out_of_range("GridDensityProvider::cellOrigin can take only indexes of 0 or 1.");
                }
        }
 
-       static void calculateOptimalProscenium(OccluderSource& source, real proscenium[4]) {
+       static void calculateOptimalProscenium(OccluderSource& source, real proscenium[4])
+       {
                source.begin();
-               if ( source.isValid() ) {
+               if (source.isValid()) {
                        const Vec3r& initialPoint = source.getGridSpacePolygon().getVertices()[0];
                        proscenium[0] = proscenium[1] = initialPoint[0];
                        proscenium[2] = proscenium[3] = initialPoint[1];
-                       while ( source.isValid() ) {
+                       while (source.isValid()) {
                                GridHelpers::expandProscenium (proscenium, source.getGridSpacePolygon());
                                source.next();
                        }
                }
-               cout << "Proscenium: (" << proscenium[0] << ", " << proscenium[1] << ", " << proscenium[2] << ", " << proscenium[3] << ")" << endl;
+               cout << "Proscenium: (" << proscenium[0] << ", " << proscenium[1] << ", " << proscenium[2]
+                    << ", " << proscenium[3] << ")" << endl;
        }
 
-       static void calculateQuickProscenium(const GridHelpers::Transform& transform, const BBox<Vec3r>& bbox, real proscenium[4]) {
+       static void calculateQuickProscenium(const GridHelpers::Transform& transform, const BBox<Vec3r>& bbox,
+                                            real proscenium[4])
+       {
                real z;
                // We want to use the z-coordinate closest to the camera to determine the proscenium face
-               if ( ::fabs(bbox.getMin()[2]) < ::fabs(bbox.getMax()[2]) ) {
+               if (::fabs(bbox.getMin()[2]) < ::fabs(bbox.getMax()[2])) {
                        z = bbox.getMin()[2];
-               } else {
+               }
+               else {
                        z = bbox.getMax()[2];
                }
                // Now calculate the proscenium according to the min and max values of the x and y coordinates
@@ -98,7 +113,8 @@ public:
                proscenium[1] = std::max(minPoint[0], maxPoint[0]);
                proscenium[2] = std::min(minPoint[1], maxPoint[1]);
                proscenium[3] = std::max(minPoint[1], maxPoint[1]);
-               cout << "Proscenium  : " << proscenium[0] << ", " << proscenium[1] << ", " << proscenium[2] << ", " << proscenium[3] << endl;
+               cout << "Proscenium  : " << proscenium[0] << ", " << proscenium[1] << ", " << proscenium[2] << ", "
+                    << proscenium[3] << endl;
        }
 
 protected:
@@ -108,24 +124,23 @@ protected:
        float _cellOrigin[2];
 };
 
-class GridDensityProviderFactory {
+class GridDensityProviderFactory
+{
        // Disallow copying and assignment
        GridDensityProviderFactory (const GridDensityProviderFactory& other);
        GridDensityProviderFactory& operator= (const GridDensityProviderFactory& other);
 
 public:
-       GridDensityProviderFactory() 
-       {
-       }
+       GridDensityProviderFactory() {}
 
-       virtual auto_ptr<GridDensityProvider> newGridDensityProvider(OccluderSource& source, const real proscenium[4]) =0;
+       virtual auto_ptr<GridDensityProvider> newGridDensityProvider(OccluderSource& source, const real proscenium[4]) = 0;
 
-       virtual auto_ptr<GridDensityProvider> newGridDensityProvider(OccluderSource& source, const BBox<Vec3r>& bbox, const GridHelpers::Transform& transform) =0;
+       virtual auto_ptr<GridDensityProvider> newGridDensityProvider(OccluderSource& source, const BBox<Vec3r>& bbox,
+                                                                    const GridHelpers::Transform& transform) = 0;
 
-       virtual auto_ptr<GridDensityProvider> newGridDensityProvider(OccluderSource& source) =0;
+       virtual auto_ptr<GridDensityProvider> newGridDensityProvider(OccluderSource& source) = 0;
 
        virtual ~GridDensityProviderFactory () {}
 };
 
-#endif // GRIDDENSITYPROVIDER_H
-
+#endif // __FREESTYLE_GRID_DENSITY_PROVIDER_H__
index 05b70af90b3e1dc964884aea793804baddc1939e..5e17c85808b8de3c46f7cad401fd2fbaf8fc12af 100644 (file)
@@ -1,74 +1,84 @@
-//
-//  Filename         : HeuristicGridDensityProviderFactory.cpp
-//  Author(s)        : Alexander Beels
-//  Purpose          : Class to define a cell grid surrounding
-//                     the projected image of a scene
-//  Date of creation : 2011-2-8
-//
-///////////////////////////////////////////////////////////////////////////////
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) 2010 Blender Foundation.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
 
-
-//
-//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
-//   with this source distribution. 
-//
-//  This program is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU General Public License
-//  as published by the Free Software Foundation; either version 2
-//  of the License, or (at your option) any later version.
-//
-//  This program is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//  GNU General Public License for more details.
-//
-//  You should have received a copy of the GNU General Public License
-//  along with this program; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
-//
-///////////////////////////////////////////////////////////////////////////////
+/** \file blender/freestyle/intern/view_map/HeuristicGridDensityProviderFactory.cpp
+ *  \ingroup freestyle
+ *  \brief Class to define a cell grid surrounding the projected image of a scene
+ *  \author Alexander Beels
+ *  \date 2011-2-8
+ */
 
 #include "HeuristicGridDensityProviderFactory.h"
 
 HeuristicGridDensityProviderFactory::HeuristicGridDensityProviderFactory(real sizeFactor, unsigned numFaces)
-       : sizeFactor(sizeFactor), numFaces(numFaces)
+: sizeFactor(sizeFactor), numFaces(numFaces)
 {
 }
 
-HeuristicGridDensityProviderFactory::~HeuristicGridDensityProviderFactory () {}
+HeuristicGridDensityProviderFactory::~HeuristicGridDensityProviderFactory() {}
 
-auto_ptr<GridDensityProvider> HeuristicGridDensityProviderFactory::newGridDensityProvider(OccluderSource& source, const real proscenium[4]) 
+auto_ptr<GridDensityProvider>
+HeuristicGridDensityProviderFactory::newGridDensityProvider(OccluderSource& source, const real proscenium[4])
 {
        auto_ptr<AverageAreaGridDensityProvider> avg(new AverageAreaGridDensityProvider(source, proscenium, sizeFactor));
        auto_ptr<Pow23GridDensityProvider> p23(new Pow23GridDensityProvider(source, proscenium, numFaces));
-       if ( avg->cellSize() > p23->cellSize() ) {
+       if (avg->cellSize() > p23->cellSize()) {
                return (auto_ptr<GridDensityProvider>) p23;
-       } else {
+       }
+       else {
                return (auto_ptr<GridDensityProvider>) avg;
        }
 }
 
-auto_ptr<GridDensityProvider> HeuristicGridDensityProviderFactory::newGridDensityProvider(OccluderSource& source, const BBox<Vec3r>& bbox, const GridHelpers::Transform& transform) 
+auto_ptr<GridDensityProvider>
+HeuristicGridDensityProviderFactory::newGridDensityProvider(OccluderSource& source, const BBox<Vec3r>& bbox,
+                                                            const GridHelpers::Transform& transform)
 {
-       auto_ptr<AverageAreaGridDensityProvider> avg(new AverageAreaGridDensityProvider(source, bbox, transform, sizeFactor));
+       auto_ptr<AverageAreaGridDensityProvider> avg(new AverageAreaGridDensityProvider(source, bbox,
+                                                                                       transform, sizeFactor));
        auto_ptr<Pow23GridDensityProvider> p23(new Pow23GridDensityProvider(source, bbox, transform, numFaces));
-       if ( avg->cellSize() > p23->cellSize() ) {
+       if (avg->cellSize() > p23->cellSize()) {
                return (auto_ptr<GridDensityProvider>) p23;
-       } else {
+       }
+       else {
                return (auto_ptr<GridDensityProvider>) avg;
        }
 }
 
-auto_ptr<GridDensityProvider> HeuristicGridDensityProviderFactory::newGridDensityProvider(OccluderSource& source) 
+auto_ptr<GridDensityProvider> HeuristicGridDensityProviderFactory::newGridDensityProvider(OccluderSource& source)
 {
        real proscenium[4];
        GridDensityProvider::calculateOptimalProscenium(source, proscenium);
        auto_ptr<AverageAreaGridDensityProvider> avg(new AverageAreaGridDensityProvider(source, proscenium, sizeFactor));
        auto_ptr<Pow23GridDensityProvider> p23(new Pow23GridDensityProvider(source, proscenium, numFaces));
-       if ( avg->cellSize() > p23->cellSize() ) {
+       if (avg->cellSize() > p23->cellSize()) {
                return (auto_ptr<GridDensityProvider>) p23;
-       } else {
+       }
+       else {
                return (auto_ptr<GridDensityProvider>) avg;
        }
 }
-
index d32c4ae4407ada718299e140da989fb694991ae3..a7557f04565d49fb87f37317eb2a6c70945bb380 100644 (file)
@@ -1,48 +1,55 @@
-//
-//  Filename         : HeuristicGridDensityProviderFactory.h
-//  Author(s)        : Alexander Beels
-//  Purpose          : Class to define a cell grid surrounding
-//                     the projected image of a scene
-//  Date of creation : 2011-2-8
-//
-///////////////////////////////////////////////////////////////////////////////
-
-
-//
-//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
-//   with this source distribution. 
-//
-//  This program is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU General Public License
-//  as published by the Free Software Foundation; either version 2
-//  of the License, or (at your option) any later version.
-//
-//  This program is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//  GNU General Public License for more details.
-//
-//  You should have received a copy of the GNU General Public License
-//  along with this program; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef HEURISTICGRIDDENSITYPROVIDERFACTORY_H
-#define HEURISTICGRIDDENSITYPROVIDERFACTORY_H
-
-// #include <memory> // provided by GridDensityProvider.h
-// #include "GridDensityProvider.h" // provided by *GridDensityProvider.h below
-#include "Pow23GridDensityProvider.h"
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) 2010 Blender Foundation.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#ifndef __FREESTYLE_HEURISTIC_GRID_DENSITY_PROVIDER_FACTORY_H__
+#define __FREESTYLE_HEURISTIC_GRID_DENSITY_PROVIDER_FACTORY_H__
+
+/** \file blender/freestyle/intern/view_map/HeuristicGridDensityProviderFactory.h
+ *  \ingroup freestyle
+ *  \brief Class to define a cell grid surrounding the projected image of a scene
+ *  \author Alexander Beels
+ *  \date 2011-2-8
+ */
+
+//#include <memory> // provided by GridDensityProvider.h
+
 #include "AverageAreaGridDensityProvider.h"
+//#include "GridDensityProvider.h" // provided by *GridDensityProvider.h below
+#include "Pow23GridDensityProvider.h"
 
-class HeuristicGridDensityProviderFactory : public GridDensityProviderFactory {
+class HeuristicGridDensityProviderFactory : public GridDensityProviderFactory
+{
 public:
        HeuristicGridDensityProviderFactory(real sizeFactor, unsigned numFaces);
-       ~HeuristicGridDensityProviderFactory ();
+       ~HeuristicGridDensityProviderFactory();
 
        auto_ptr<GridDensityProvider> newGridDensityProvider(OccluderSource& source, const real proscenium[4]);
-       auto_ptr<GridDensityProvider> newGridDensityProvider(OccluderSource& source, const BBox<Vec3r>& bbox, const GridHelpers::Transform& transform);
+       auto_ptr<GridDensityProvider> newGridDensityProvider(OccluderSource& source, const BBox<Vec3r>& bbox,
+                                                            const GridHelpers::Transform& transform);
        auto_ptr<GridDensityProvider> newGridDensityProvider(OccluderSource& source);
 
 protected:
@@ -50,5 +57,4 @@ protected:
        unsigned numFaces;
 };
 
-#endif // HEURISTICGRIDDENSITYPROVIDERFACTORY_H
-
+#endif // __FREESTYLE_HEURISTIC_GRID_DENSITY_PROVIDER_FACTORY_H__
index 48d956eec194b4dcc0970a70ded90fcb307a4eba..bbf93deadb715980c41a93fe3b0378d2368fbd06 100644 (file)
@@ -1,45 +1,53 @@
-//
-//  Filename         : Interface0D.h
-//  Author(s)        : Emmanuel Turquin
-//  Purpose          : Interface to 0D elts
-//  Date of creation : 01/07/2003
-//
-///////////////////////////////////////////////////////////////////////////////
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) 2010 Blender Foundation.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
 
+#ifndef __FREESTYLE_INTERFACE_0D_H__
+#define __FREESTYLE_INTERFACE_0D_H__
 
-//
-//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
-//   with this source distribution. 
-//
-//  This program is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU General Public License
-//  as published by the Free Software Foundation; either version 2
-//  of the License, or (at your option) any later version.
-//
-//  This program is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//  GNU General Public License for more details.
-//
-//  You should have received a copy of the GNU General Public License
-//  along with this program; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef  INTERFACE0D_H
-# define INTERFACE0D_H
-
-# include <Python.h>
-# include <string>
-# include <iostream>
-# include "../system/Id.h"
-# include "../system/Precision.h"
-# include "../winged_edge/Nature.h"
-# include "../geometry/Geom.h"
-using namespace std;
+/** \file blender/freestyle/intern/view_map/Interface0D.h
+ *  \ingroup freestyle
+ *  \brief Interface to 0D elts
+ *  \author Emmanuel Turquin
+ *  \date 01/07/2003
+ */
+
+#include <iostream>
+#include <Python.h>
+#include <string>
+
+#include "../geometry/Geom.h"
 
+#include "../system/Id.h"
 #include "../system/Iterator.h" //soc 
+#include "../system/Precision.h"
+
+#include "../winged_edge/Nature.h"
+
+using namespace std;
 
 //
 // Interface0D
@@ -51,114 +59,128 @@ class SVertex;
 class ViewVertex;
 class NonTVertex;
 class TVertex;
+
 /*! Base class for any 0D element. */
 class Interface0D
 {
 public:
-
-  /*! Default constructor */
-  Interface0D() {}
-  virtual ~Interface0D() {}; //soc
-  /*! Returns the string "Interface0D".*/
-  virtual string getExactTypeName() const {
-    return "Interface0D";
-  }
-
-  // Data access methods
-
-  /*! Returns the 3D x coordinate of the point. */ 
-  virtual real getX() const {
-         PyErr_SetString(PyExc_TypeError, "method getX() not properly overridden");
-         return 0;
-  }
-
-  /*! Returns the 3D y coordinate of the point. */ 
-  virtual real getY() const {
-         PyErr_SetString(PyExc_TypeError, "method getY() not properly overridden");
-         return 0;
-  }
-
-  /*!  Returns the 3D z coordinate of the point. */ 
-  virtual real getZ() const {
-         PyErr_SetString(PyExc_TypeError, "method getZ() not properly overridden");
-         return 0;
-  }
-
-  /*!  Returns the 3D point. */ 
-  virtual Geometry::Vec3f getPoint3D() const {
-         PyErr_SetString(PyExc_TypeError, "method getPoint3D() not properly overridden");
-         return 0;
-  }
-
-  /*! Returns the 2D x coordinate of the point. */ 
-  virtual real getProjectedX() const {
-         PyErr_SetString(PyExc_TypeError, "method getProjectedX() not properly overridden");
-         return 0;
-  }
-
-  /*! Returns the 2D y coordinate of the point. */ 
-  virtual real getProjectedY() const {
-         PyErr_SetString(PyExc_TypeError, "method getProjectedY() not properly overridden");
-         return 0;
-  }
-
-  /*! Returns the 2D z coordinate of the point. */ 
-  virtual real getProjectedZ() const {
-         PyErr_SetString(PyExc_TypeError, "method getProjectedZ() not properly overridden");
-         return 0;
-  }
-
-  /*!  Returns the 2D point. */ 
-  virtual Geometry::Vec2f getPoint2D() const {
-         PyErr_SetString(PyExc_TypeError, "method getPoint2D() not properly overridden");
-         return 0;
-  }
-       
-  /*! Returns the FEdge that lies between this Interface0D and the
-   *  Interface0D given as argument. */
-  virtual FEdge* getFEdge(Interface0D&) {
-         PyErr_SetString(PyExc_TypeError, "method getFEdge() not properly overridden");
-         return 0;
-  }
-
-  /*! Returns the Id of the point. */ 
-  virtual Id getId() const {
-         PyErr_SetString(PyExc_TypeError, "method getId() not properly overridden");
-         return 0;
-  }
-
-  /*! Returns the nature of the point. */ 
-  virtual Nature::VertexNature getNature() const {
-         PyErr_SetString(PyExc_TypeError, "method getNature() not properly overridden");
-         return Nature::POINT;
-  }    
-
-
-  /*! Cast the Interface0D in SVertex if it can be. */ 
-  virtual SVertex * castToSVertex(){
-         PyErr_SetString(PyExc_TypeError, "method castToSVertex() not properly overridden");
-         return 0;
-  }
-
-  /*! Cast the Interface0D in ViewVertex if it can be. */ 
-  virtual ViewVertex * castToViewVertex(){
-         PyErr_SetString(PyExc_TypeError, "method castToViewVertex() not properly overridden");
-         return 0;
-  }
-
-  /*! Cast the Interface0D in NonTVertex if it can be. */ 
-  virtual NonTVertex * castToNonTVertex(){
-         PyErr_SetString(PyExc_TypeError, "method castToNonTVertex() not properly overridden");
-         return 0;
-  }
-
-  /*! Cast the Interface0D in TVertex if it can be. */ 
-  virtual TVertex * castToTVertex(){
-         PyErr_SetString(PyExc_TypeError, "method castToTVertex() not properly overridden");
-         return 0;
-  }
-       
+       /*! Default constructor */
+       Interface0D() {}
+       virtual ~Interface0D() {}; //soc
+
+       /*! Returns the string "Interface0D". */
+       virtual string getExactTypeName() const
+       {
+               return "Interface0D";
+       }
+
+       // Data access methods
+
+       /*! Returns the 3D x coordinate of the point. */
+       virtual real getX() const
+       {
+               PyErr_SetString(PyExc_TypeError, "method getX() not properly overridden");
+               return 0;
+       }
+
+       /*! Returns the 3D y coordinate of the point. */
+       virtual real getY() const
+       {
+               PyErr_SetString(PyExc_TypeError, "method getY() not properly overridden");
+               return 0;
+       }
+
+       /*!  Returns the 3D z coordinate of the point. */
+       virtual real getZ() const
+       {
+               PyErr_SetString(PyExc_TypeError, "method getZ() not properly overridden");
+               return 0;
+       }
+
+       /*!  Returns the 3D point. */
+       virtual Geometry::Vec3f getPoint3D() const
+       {
+               PyErr_SetString(PyExc_TypeError, "method getPoint3D() not properly overridden");
+               return 0;
+       }
+
+       /*! Returns the 2D x coordinate of the point. */
+       virtual real getProjectedX() const
+       {
+               PyErr_SetString(PyExc_TypeError, "method getProjectedX() not properly overridden");
+               return 0;
+       }
+
+       /*! Returns the 2D y coordinate of the point. */
+       virtual real getProjectedY() const
+       {
+               PyErr_SetString(PyExc_TypeError, "method getProjectedY() not properly overridden");
+               return 0;
+       }
+
+       /*! Returns the 2D z coordinate of the point. */
+       virtual real getProjectedZ() const
+       {
+               PyErr_SetString(PyExc_TypeError, "method getProjectedZ() not properly overridden");
+               return 0;
+       }
+
+       /*!  Returns the 2D point. */
+       virtual Geometry::Vec2f getPoint2D() const
+       {
+               PyErr_SetString(PyExc_TypeError, "method getPoint2D() not properly overridden");
+               return 0;
+       }
+
+       /*! Returns the FEdge that lies between this Interface0D and the Interface0D given as argument. */
+       virtual FEdge* getFEdge(Interface0D&)
+       {
+               PyErr_SetString(PyExc_TypeError, "method getFEdge() not properly overridden");
+               return 0;
+       }
+
+       /*! Returns the Id of the point. */
+       virtual Id getId() const
+       {
+               PyErr_SetString(PyExc_TypeError, "method getId() not properly overridden");
+               return 0;
+       }
+
+       /*! Returns the nature of the point. */
+       virtual Nature::VertexNature getNature() const
+       {
+               PyErr_SetString(PyExc_TypeError, "method getNature() not properly overridden");
+               return Nature::POINT;
+       }
+
+
+       /*! Cast the Interface0D in SVertex if it can be. */
+       virtual SVertex *castToSVertex()
+       {
+               PyErr_SetString(PyExc_TypeError, "method castToSVertex() not properly overridden");
+               return 0;
+       }
+
+       /*! Cast the Interface0D in ViewVertex if it can be. */
+       virtual ViewVertex * castToViewVertex()
+       {
+               PyErr_SetString(PyExc_TypeError, "method castToViewVertex() not properly overridden");
+               return 0;
+       }
+
+       /*! Cast the Interface0D in NonTVertex if it can be. */
+       virtual NonTVertex *castToNonTVertex()
+       {
+               PyErr_SetString(PyExc_TypeError, "method castToNonTVertex() not properly overridden");
+               return 0;
+       }
+
+       /*! Cast the Interface0D in TVertex if it can be. */
+       virtual TVertex *castToTVertex()
+       {
+               PyErr_SetString(PyExc_TypeError, "method castToTVertex() not properly overridden");
+               return 0;
+       }
 };
 
 
@@ -170,39 +192,42 @@ public:
 class Interface0DIteratorNested : public Iterator
 {
 public:
+       virtual ~Interface0DIteratorNested() {}
 
-  virtual ~Interface0DIteratorNested() {}
+       virtual string getExactTypeName() const
+       {
+               return "Interface0DIteratorNested";
+       }
 
-  virtual string getExactTypeName() const {
-    return "Interface0DIteratorNested";
-  }
+       virtual Interface0D& operator*() = 0;
 
-  virtual Interface0D& operator*() = 0;
+       virtual Interface0D* operator->()
+       {
+               return &(operator*());
+       }
 
-  virtual Interface0D* operator->() {
-    return &(operator*());
-  }
+       virtual int increment() = 0;
 
-  virtual int increment() = 0;
+       virtual int decrement() = 0;
 
-  virtual int decrement() = 0;
+       virtual bool isBegin() const = 0;
 
-  virtual bool isBegin() const = 0;
+       virtual bool isEnd() const = 0;
 
-  virtual bool isEnd() const = 0;
+       virtual bool operator==(const Interface0DIteratorNested& it) const = 0;
 
-  virtual bool operator==(const Interface0DIteratorNested& it) const = 0;
+       virtual bool operator!=(const Interface0DIteratorNested& it) const
+       {
+               return !(*this == it);
+       }
 
-  virtual bool operator!=(const Interface0DIteratorNested& it) const {
-    return !(*this == it);
-  }
+       /*! Returns the curvilinear abscissa */
+       virtual float t() const = 0;
 
-  /*! Returns the curvilinear abscissa */
-  virtual float t() const = 0;
-  /*! Returns the point parameter 0<u<1 */
-  virtual float u() const = 0;
+       /*! Returns the point parameter 0<u<1 */
+       virtual float u() const = 0;
 
-  virtual Interface0DIteratorNested* copy() const = 0;
+       virtual Interface0DIteratorNested* copy() const = 0;
 };
 
 
@@ -212,149 +237,154 @@ public:
 //////////////////////////////////////////////////
 
 /*! Class defining an iterator over Interface0D elements.
- *  An instance of this iterator is always obtained
- *  from a 1D element.
- *  \attention In the scripting language, you must call
- *  \code it2 = Interface0DIterator(it1) \endcode instead of \code it2 = it1 \endcode
- *  where \a it1 and \a it2 are 2 Interface0DIterator.
+ *  An instance of this iterator is always obtained from a 1D element.
+ *  \attention In the scripting language, you must call \code it2 = Interface0DIterator(it1) \endcode instead of
+ *  \code it2 = it1 \endcode where \a it1 and \a it2 are 2 Interface0DIterator.
  *  Otherwise, incrementing \a it1 will also increment \a it2.
  */
 class Interface0DIterator : public Iterator
 {
 public:
+       Interface0DIterator(Interface0DIteratorNested* it = NULL)
+       {
+               _iterator = it;
+       }
+
+       /*! Copy constructor */
+       Interface0DIterator(const Interface0DIterator& it)
+       {
+               _iterator = it._iterator->copy();
+       }
+
+       /*! Destructor */
+       virtual ~Interface0DIterator()
+       {
+               if (_iterator)
+                       delete _iterator;
+       }
+
+       /*! Operator =
+        *  \attention In the scripting language, you must call \code it2 = Interface0DIterator(it1) \endcode instead of
+        *  \code it2 = it1 \endcode where \a it1 and \a it2 are 2 Interface0DIterator.
+        *  Otherwise, incrementing \a it1 will also increment \a it2.
+        */
+       Interface0DIterator& operator=(const Interface0DIterator& it)
+       {
+               if(_iterator)
+                       delete _iterator;
+               _iterator = it._iterator->copy();
+               return *this;
+       }
+
+       /*! Returns the string "Interface0DIterator". */
+       virtual string getExactTypeName() const
+       {
+               if (!_iterator)
+                       return "Interface0DIterator";
+               return _iterator->getExactTypeName() + "Proxy";
+       }
+
+       // FIXME test it != 0 (exceptions ?)
+
+       /*! Returns a reference to the pointed Interface0D.
+        *  In the scripting language, you must call "getObject()" instead using this operator.
+        */
+       Interface0D& operator*()
+       {
+               return _iterator->operator*();
+       }
+
+       /*! Returns a pointer to the pointed Interface0D.
+        *  Can't be called in the scripting language.
+        */
+       Interface0D *operator->()
+       {
+               return &(operator*());
+       }
+
+       /*! Increments. In the scripting language, call "increment()". */
+       Interface0DIterator& operator++()
+       {
+               _iterator->increment();
+               return *this;
+       }
+
+       /*! Increments. In the scripting language, call "increment()". */
+       Interface0DIterator operator++(int)
+       {
+               Interface0DIterator ret(*this);
+               _iterator->increment();
+               return ret;
+       }
+
+       /*! Decrements. In the scripting language, call "decrement()". */
+       Interface0DIterator& operator--()
+       {
+               _iterator->decrement();
+               return *this;
+       }
+
+       /*! Decrements. In the scripting language, call "decrement()". */
+       Interface0DIterator operator--(int)
+       {
+               Interface0DIterator ret(*this);
+               _iterator->decrement();
+               return ret;
+       }
+
+       /*! Increments. */
+       virtual int increment()
+       {
+               return _iterator->increment();
+       }
+
+       /*! Decrements. */
+       virtual int decrement()
+       {
+               return _iterator->decrement();
+       }
+
+       /*! Returns true if the pointed Interface0D is the first of the 1D element containing the points over which
+        *  we're iterating.
+        */
+       virtual bool isBegin() const
+       {
+               return _iterator->isBegin();
+       }
+
+       /*! Returns true if the pointed Interface0D is after the after the last point of the 1D element we're
+        *  iterating from. */
+       virtual bool isEnd() const
+       {
+               return _iterator->isEnd();
+       }
+
+       /*! operator == . */
+       bool operator==(const Interface0DIterator& it) const
+       {
+               return _iterator->operator==(*(it._iterator));
+       }
+
+       /*! operator != . */
+       bool operator!=(const Interface0DIterator& it) const
+       {
+               return !(*this == it);
+       }
+
+       /*! Returns the curvilinear abscissa. */
+       inline float t() const
+       {
+               return _iterator->t();
+       }
+
+       /*! Returns the point parameter in the curve 0<=u<=1. */
+       inline float u() const
+       {
+               return _iterator->u();
+       }
 
-  Interface0DIterator(Interface0DIteratorNested* it = NULL) {
-    _iterator = it;
-  }
-
-  /*! Copy constructor */
-  Interface0DIterator(const Interface0DIterator& it) {
-    _iterator = it._iterator->copy();
-  }
-
-  /*! Destructor */
-  virtual ~Interface0DIterator() {
-    if (_iterator)
-      delete _iterator;
-  }
-
-  /*! Operator =
-   *  \attention In the scripting language, you must call
-   *  \code it2 = Interface0DIterator(it1) \endcode instead of \code it2 = it1 \endcode
-   *  where \a it1 and \a it2 are 2 Interface0DIterator.
-   *  Otherwise, incrementing \a it1 will also increment \a it2.
-   */
-  Interface0DIterator& operator=(const Interface0DIterator& it) {
-    if(_iterator)
-      delete _iterator;
-    _iterator = it._iterator->copy();
-    return *this;
-  }
-
-  /*! Returns the string "Interface0DIterator". */
-  virtual string getExactTypeName() const {
-    if (!_iterator)
-      return "Interface0DIterator";
-    return _iterator->getExactTypeName() + "Proxy";
-  }
-
-  // FIXME test it != 0 (exceptions ?)
-
-  /*! Returns a reference to the pointed Interface0D.
-   *  In the scripting language, you must call
-   *  "getObject()" instead using this operator.
-   */ 
-  Interface0D& operator*() {
-    return _iterator->operator*();
-  }
-
-  /*! Returns a pointer to the pointed Interface0D.
-   *  Can't be called in the scripting language.
-   */
-  Interface0D* operator->() {
-    return &(operator*());
-  }
-
-  /*! Increments. In the scripting language, call
-   *  "increment()".
-   */
-  Interface0DIterator& operator++() {
-    _iterator->increment();
-    return *this;
-  }
-
-  /*! Increments. In the scripting language, call
-   *  "increment()".
-   */
-  Interface0DIterator operator++(int) {
-    Interface0DIterator ret(*this);
-    _iterator->increment();
-    return ret;
-  }
-
-  /*! Decrements. In the scripting language, call
-   *  "decrement()".
-   */
-  Interface0DIterator& operator--() {
-    _iterator->decrement();
-    return *this;
-  }
-
-  /*! Decrements. In the scripting language, call
-   *  "decrement()".
-   */
-  Interface0DIterator operator--(int) {
-    Interface0DIterator ret(*this);
-    _iterator->decrement();
-    return ret;
-  }
-
-  /*! Increments. */
-  virtual int increment() {
-    return _iterator->increment();
-  }
-  
-  /*! Decrements. */
-  virtual int decrement() {
-    return _iterator->decrement();
-  }
-
-  /*! Returns true if the pointed Interface0D is the
-   * first of the 1D element containing the points over
-   * which we're iterating.
-   */
-  virtual bool isBegin() const {
-    return _iterator->isBegin();
-  }
-
-  /*! Returns true if the pointed Interface0D is after the
-   * after the last point of the 1D element we're iterating from.
-   */
-  virtual bool isEnd() const {
-    return _iterator->isEnd();
-  }
-
-  /*! operator == . */
-  bool operator==(const Interface0DIterator& it) const {
-    return _iterator->operator==(*(it._iterator));
-  }
-
-  /*! operator != . */
-  bool operator!=(const Interface0DIterator& it) const {
-    return !(*this == it);
-  }
-
-  /*! Returns the curvilinear abscissa. */
-  inline float t() const {
-    return _iterator->t();
-  }
-  /*! Returns the point parameter in the curve 0<=u<=1. */
-  inline float u() const {
-    return _iterator->u();
-  }
 protected:
-
-  Interface0DIteratorNested* _iterator;
+       Interface0DIteratorNested *_iterator;
 };
 
-#endif // INTERFACE0D_H
+#endif // __FREESTYLE_INTERFACE_0D_H__
index 60cc0ebcb7eee852b7b8d3a34433ffb4e7aaf3e4..440c6f275b81d160673184381f7ce56445096b1d 100644 (file)
-//
-//  Filename         : Interface1D.h
-//  Author(s)        : Emmanuel Turquin
-//  Purpose          : Interface to 1D elts
-//  Date of creation : 01/07/2003
-//
-///////////////////////////////////////////////////////////////////////////////
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) 2010 Blender Foundation.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
 
+#ifndef __FREESTYLE_INTERFACE_1D_H__
+#define __FREESTYLE_INTERFACE_1D_H__
 
-//
-//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
-//   with this source distribution. 
-//
-//  This program is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU General Public License
-//  as published by the Free Software Foundation; either version 2
-//  of the License, or (at your option) any later version.
-//
-//  This program is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//  GNU General Public License for more details.
-//
-//  You should have received a copy of the GNU General Public License
-//  along with this program; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
-//
-///////////////////////////////////////////////////////////////////////////////
+/** \file blender/freestyle/intern/view_map/Interface1D.h
+ *  \ingroup freestyle
+ *  \brief Interface 1D and related tools definitions
+ *  \author Emmanuel Turquin
+ *  \date 01/07/2003
+ */
+
+#include <float.h>
+#include <iostream>
+#include <Python.h>
+#include <string>
 
-#ifndef  INTERFACE1D_H
-# define INTERFACE1D_H
+#include "Functions0D.h"
 
-# include <Python.h>
-# include <string>
-# include <iostream>
-# include <float.h>
-# include "../system/Id.h"
-# include "../system/Precision.h"
-# include "../winged_edge/Nature.h"
-# include "Functions0D.h"
+#include "../system/Id.h"
+#include "../system/Precision.h"
+
+#include "../winged_edge/Nature.h"
 
 using namespace std;
-/*! \file Interface1D.h
- *  Interface1D and related tools definitions
- */
+
 // Integration method
-/*! The different integration
- *  methods that can be invoked
- *  to integrate into a single value the set of values obtained
+/*! The different integration methods that can be invoked to integrate into a single value the set of values obtained
  *  from each 0D element of a 1D element.
  */
 typedef enum {
-  MEAN,/*!< The value computed for the 1D element is the mean of the values obtained for the 0D elements.*/
-  MIN,/*!< The value computed for the 1D element is the minimum of the values obtained for the 0D elements.*/
-  MAX,/*!< The value computed for the 1D element is the maximum of the values obtained for the 0D elements.*/
-  FIRST,/*!< The value computed for the 1D element is the first of the values obtained for the 0D elements.*/
-  LAST/*!< The value computed for the 1D element is the last of the values obtained for the 0D elements.*/
+       MEAN,  /*!< The value computed for the 1D element is the mean of the values obtained for the 0D elements.*/
+       MIN,   /*!< The value computed for the 1D element is the minimum of the values obtained for the 0D elements.*/
+       MAX,   /*!< The value computed for the 1D element is the maximum of the values obtained for the 0D elements.*/
+       FIRST, /*!< The value computed for the 1D element is the first of the values obtained for the 0D elements.*/
+       LAST   /*!< The value computed for the 1D element is the last of the values obtained for the 0D elements.*/
 } IntegrationType;
 
-/*! Returns a single
- *  value from a set of values evaluated at each 0D element
- *  of this 1D element.
+/*! Returns a single value from a set of values evaluated at each 0D element of this 1D element.
  *  \param fun
  *    The UnaryFunction0D used to compute a value at each Interface0D.
  *  \param it
- *    The Interface0DIterator used to iterate over the 0D elements of
- *    this 1D element. The integration will occur over the 0D elements
- *    starting from the one pointed by it.
+ *    The Interface0DIterator used to iterate over the 0D elements of this 1D element. The integration will occur
+ *    over the 0D elements starting from the one pointed by it.
  *  \param it_end
- *    The Interface0DIterator pointing the end of the 0D elements of the
- *    1D element.
+ *    The Interface0DIterator pointing the end of the 0D elements of the 1D element.
  *  \param integration_type
- *    The integration method used to compute a single value from
- *    a set of values.
+ *    The integration method used to compute a single value from a set of values.
  *  \return the single value obtained for the 1D element.
  */
 template <class T>
-T integrate(UnaryFunction0D<T>& fun,
-           Interface0DIterator it,
-           Interface0DIterator it_end,
-           IntegrationType integration_type = MEAN) {
-  T res;
-  unsigned size;
-  switch (integration_type) {
-  case MIN:
-       fun(it);
-       res = fun.result;++it;
-    for (; !it.isEnd(); ++it) {
-         fun(it);
-      if (fun.result < res)
-               res = fun.result;
-    }
-    break;
-  case MAX:
-       fun(it);
-       res = fun.result;++it;
-    for (; !it.isEnd(); ++it) {
-         fun(it);
-      if (fun.result > res)
-           res = fun.result;
-    }
-    break;
-  case FIRST:
-       fun(it);
-       res = fun.result;
-    break;
-  case LAST:
-       fun(--it_end);
-       res = fun.result;
-    break;
-  case MEAN:
-  default:
-       fun(it);
-       res = fun.result;++it;
-       for (size = 1; !it.isEnd(); ++it, ++size) {
-         fun(it);
-         res += fun.result;
+T integrate(UnaryFunction0D<T>& fun, Interface0DIterator it, Interface0DIterator it_end,
+            IntegrationType integration_type = MEAN)
+{
+       T res;
+       unsigned size;
+       switch (integration_type) {
+               case MIN:
+                       fun(it);
+                       res = fun.result;
+                       ++it;
+                       for (; !it.isEnd(); ++it) {
+                               fun(it);
+                               if (fun.result < res)
+                                       res = fun.result;
+                       }
+                       break;
+               case MAX:
+                       fun(it);
+                       res = fun.result;
+                       ++it;
+                       for (; !it.isEnd(); ++it) {
+                               fun(it);
+                               if (fun.result > res)
+                                       res = fun.result;
+                       }
+                       break;
+               case FIRST:
+                       fun(it);
+                       res = fun.result;
+                       break;
+               case LAST:
+                       fun(--it_end);
+                       res = fun.result;
+                       break;
+               case MEAN:
+                       default:
+                       fun(it);
+                       res = fun.result;
+                       ++it;
+                       for (size = 1; !it.isEnd(); ++it, ++size) {
+                               fun(it);
+                               res += fun.result;
+                       }
+                       res /= (size ? size : 1);
+                       break;
        }
-    res /= (size ? size : 1);
-    break;
-  }
-  return res;
+       return res;
 }
 
 //
@@ -131,96 +132,99 @@ T integrate(UnaryFunction0D<T>& fun,
 class Interface1D
 {
 public:
+       /*! Default constructor */
+       Interface1D()
+       {
+               _timeStamp = 0;
+       }
+
+       virtual ~Interface1D() {}; //soc
+
+       /*! Returns the string "Interface1D". */
+       virtual string getExactTypeName() const
+       {
+               return "Interface1D";
+       }
+
+       // Iterator access
 
-  /*! Default constructor */
-  Interface1D() {_timeStamp=0;}
-  virtual ~Interface1D() {}; //soc
-
-  /*! Returns the string "Interface1D" .*/
-  virtual string getExactTypeName() const {
-    return "Interface1D";
-  }
-
-  // Iterator access
-
-  /*! Returns an iterator over the Interface1D vertices,
-   *  pointing to the first vertex.
-   */
-  virtual Interface0DIterator verticesBegin() {
-         PyErr_SetString(PyExc_TypeError, "method verticesBegin() not properly overridden");
-         return Interface0DIterator();
-  }
-       
-  /*! Returns an iterator over the Interface1D vertices,
-   *  pointing after the last vertex.
-   */
-  virtual Interface0DIterator verticesEnd(){
-         PyErr_SetString(PyExc_TypeError, "method verticesEnd() not properly overridden");
-         return Interface0DIterator();
-  }
-
-  /*! Returns an iterator over the Interface1D points,
-   *  pointing to the first point. The difference with
-   *  verticesBegin() is that here we can iterate over
-   *  points of the 1D element at a any given sampling.
-   *  Indeed, for each iteration, a virtual point is created.
-   *  \param t
-   *    The sampling with which we want to iterate over points of
-   *    this 1D element.
-   */
-  virtual Interface0DIterator pointsBegin(float t=0.f) {
-         PyErr_SetString(PyExc_TypeError, "method pointsBegin() not properly overridden");
-         return Interface0DIterator();
-  }
-
-  /*! Returns an iterator over the Interface1D points,
-   *  pointing after the last point. The difference with
-   *  verticesEnd() is that here we can iterate over
-   *  points of the 1D element at a any given sampling.
-   *  Indeed, for each iteration, a virtual point is created.
-   *  \param t
-   *    The sampling with which we want to iterate over points of
-   *    this 1D element.
-   */
-  virtual Interface0DIterator pointsEnd(float t=0.f) {
-         PyErr_SetString(PyExc_TypeError, "method pointsEnd() not properly overridden");
-         return Interface0DIterator();
-  }
-
-  // Data access methods
-
-  /*! Returns the 2D length of the 1D element. */
-  virtual real getLength2D() const {
-         PyErr_SetString(PyExc_TypeError, "method getLength2D() not properly overridden");
-         return 0;
-  }
-
-  /*! Returns the Id of the 1D element .*/
-  virtual Id getId() const {
-         PyErr_SetString(PyExc_TypeError, "method getId() not properly overridden");
-         return Id(0, 0);
-  }    
-
-
-  // FIXME: ce truc n'a rien a faire la...(c une requete complexe qui doit etre ds les Function1D)
-  /*! Returns the nature of the 1D element. */
-  virtual Nature::EdgeNature getNature() const {
-         PyErr_SetString(PyExc_TypeError, "method getNature() not properly overridden");
-         return Nature::NO_FEATURE;
-  }    
-  
-  /*! Returns the time stamp of the 1D element. Mainly used for selection. */
-  virtual unsigned getTimeStamp() const {
-    return _timeStamp;
-  }
-  
-  /*! Sets the time stamp for the 1D element. */
-  inline void setTimeStamp(unsigned iTimeStamp){
-    _timeStamp = iTimeStamp;
-  }
+       /*! Returns an iterator over the Interface1D vertices, pointing to the first vertex. */
+       virtual Interface0DIterator verticesBegin()
+       {
+               PyErr_SetString(PyExc_TypeError, "method verticesBegin() not properly overridden");
+               return Interface0DIterator();
+       }
+
+       /*! Returns an iterator over the Interface1D vertices, pointing after the last vertex. */
+       virtual Interface0DIterator verticesEnd()
+       {
+               PyErr_SetString(PyExc_TypeError, "method verticesEnd() not properly overridden");
+               return Interface0DIterator();
+       }
+
+       /*! Returns an iterator over the Interface1D points, pointing to the first point. The difference with
+        *  verticesBegin() is that here we can iterate over points of the 1D element at a any given sampling.
+        *  Indeed, for each iteration, a virtual point is created.
+        *  \param t
+        *    The sampling with which we want to iterate over points of this 1D element.
+        */
+       virtual Interface0DIterator pointsBegin(float t = 0.0f)
+       {
+               PyErr_SetString(PyExc_TypeError, "method pointsBegin() not properly overridden");
+               return Interface0DIterator();
+       }
+
+       /*! Returns an iterator over the Interface1D points, pointing after the last point. The difference with
+        *  verticesEnd() is that here we can iterate over points of the 1D element at a any given sampling.
+        *  Indeed, for each iteration, a virtual point is created.
+        *  \param t
+        *    The sampling with which we want to iterate over points of this 1D element.
+        */
+       virtual Interface0DIterator pointsEnd(float t = 0.0f)
+       {
+               PyErr_SetString(PyExc_TypeError, "method pointsEnd() not properly overridden");
+               return Interface0DIterator();
+       }
+
+       // Data access methods
+
+       /*! Returns the 2D length of the 1D element. */
+       virtual real getLength2D() const
+       {
+               PyErr_SetString(PyExc_TypeError, "method getLength2D() not properly overridden");
+               return 0;
+       }
+
+       /*! Returns the Id of the 1D element. */
+       virtual Id getId() const
+       {
+               PyErr_SetString(PyExc_TypeError, "method getId() not properly overridden");
+               return Id(0, 0);
+       }
+
+
+       // FIXME: ce truc n'a rien a faire la...(c une requete complexe qui doit etre ds les Function1D)
+       /*! Returns the nature of the 1D element. */
+       virtual Nature::EdgeNature getNature() const
+       {
+               PyErr_SetString(PyExc_TypeError, "method getNature() not properly overridden");
+               return Nature::NO_FEATURE;
+       }
+
+       /*! Returns the time stamp of the 1D element. Mainly used for selection. */
+       virtual unsigned getTimeStamp() const
+       {
+               return _timeStamp;
+       }
+
+       /*! Sets the time stamp for the 1D element. */
+       inline void setTimeStamp(unsigned iTimeStamp)
+       {
+               _timeStamp = iTimeStamp;
+       }
 
 protected:
-  unsigned _timeStamp;
+       unsigned _timeStamp;
 };
 
-#endif // INTERFACE1D_H
+#endif // __FREESTYLE_INTERFACE_1D_H__
index 356e281be4b22b64b2b896ff9bbdd05740ad5585..5af618dd6f69e9b6a8f2de822f2aaa3a6ca65313 100644 (file)
@@ -1,65 +1,73 @@
-//
-//  Filename         : OccluderSource.h
-//  Author(s)        : Alexander Beels
-//  Purpose          : Class to define a cell grid surrounding
-//                     the projected image of a scene
-//  Date of creation : 2010-12-21
-//
-///////////////////////////////////////////////////////////////////////////////
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) 2010 Blender Foundation.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file blender/freestyle/intern/view_map/OccluderSource.cpp
+ *  \ingroup freestyle
+ *  \brief Class to define a cell grid surrounding the projected image of a scene
+ *  \author Alexander Beels
+ *  \date 2010-12-21
+ */
 
-
-//
-//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
-//   with this source distribution. 
-//
-//  This program is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU General Public License
-//  as published by the Free Software Foundation; either version 2
-//  of the License, or (at your option) any later version.
-//
-//  This program is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//  GNU General Public License for more details.
-//
-//  You should have received a copy of the GNU General Public License
-//  along with this program; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
-//
-///////////////////////////////////////////////////////////////////////////////
+#include <algorithm>
 
 #include "OccluderSource.h"
-#include <algorithm>
 
-OccluderSource::OccluderSource (const GridHelpers::Transform& t, WingedEdge& we) : wingedEdge(we), valid(false), transform(t) {
+OccluderSource::OccluderSource(const GridHelpers::Transform& t, WingedEdge& we)
+: wingedEdge(we), valid(false), transform(t)
+{
        begin();
 }
 
-OccluderSource::~OccluderSource() {
-}
+OccluderSource::~OccluderSource() {}
 
-void OccluderSource::buildCachedPolygon() {
+void OccluderSource::buildCachedPolygon()
+{
        vector<Vec3r> vertices(GridHelpers::enumerateVertices((*currentFace)->getEdgeList()));
        // This doesn't work, because our functor's polymorphism won't survive the copy:
        // std::transform(vertices.begin(), vertices.end(), vertices.begin(), transform);
        // so we have to do:
-       for ( vector<Vec3r>::iterator i = vertices.begin(); i != vertices.end(); ++i ) {
+       for (vector<Vec3r>::iterator i = vertices.begin(); i != vertices.end(); ++i) {
                (*i) = transform(*i);
        }
        cachedPolygon = Polygon3r(vertices, transform((*currentFace)->GetNormal()));
 }
 
-void OccluderSource::begin() {
-       vector<WShape*>& wshapes = wingedEdge.getWShapes();
+void OccluderSource::begin()
+{
+       vector<WShape*>& wshapes = wingedEdge.getWShapes();
        currentShape = wshapes.begin();
        shapesEnd = wshapes.end();
        valid = false;
-       if ( currentShape != shapesEnd ) {
+       if (currentShape != shapesEnd) {
                vector<WFace*>& wFaces = (*currentShape)->GetFaceList();
                currentFace = wFaces.begin();
                facesEnd = wFaces.end();
 
-               if ( currentFace != facesEnd ) {
+               if (currentFace != facesEnd) {
                        buildCachedPolygon();
                        valid = true;
                }
@@ -67,14 +75,15 @@ void OccluderSource::begin() {
 }
 
 bool OccluderSource::next() {
-       if ( valid ) {
+       if (valid) {
                ++currentFace;
-               while ( currentFace == facesEnd ) {
+               while (currentFace == facesEnd) {
                        ++currentShape;
-                       if ( currentShape == shapesEnd ) {
+                       if (currentShape == shapesEnd) {
                                valid = false;
                                return false;
-                       } else {
+                       }
+                       else {
                                vector<WFace*>& wFaces = (*currentShape)->GetFaceList();
                                currentFace = wFaces.begin();
                                facesEnd = wFaces.end();
@@ -86,40 +95,47 @@ bool OccluderSource::next() {
        return false;
 }
 
-bool OccluderSource::isValid() {
+bool OccluderSource::isValid()
+{
        // Or:
        // return currentShapes != shapesEnd && currentFace != facesEnd;
        return valid;
 }
 
-WFace* OccluderSource::getWFace() {
+WFace *OccluderSource::getWFace()
+{
        return valid ? *currentFace : NULL;
 }
 
-Polygon3r OccluderSource::getCameraSpacePolygon() {
+Polygon3r OccluderSource::getCameraSpacePolygon()
+{
        return Polygon3r(GridHelpers::enumerateVertices((*currentFace)->getEdgeList()), (*currentFace)->GetNormal());
 }
 
-Polygon3r& OccluderSource::getGridSpacePolygon() {
+Polygon3r& OccluderSource::getGridSpacePolygon()
+{
        return cachedPolygon;
 }
 
-void OccluderSource::getOccluderProscenium(real proscenium[4]) {
+void OccluderSource::getOccluderProscenium(real proscenium[4])
+{
        begin();
        const Vec3r& initialPoint = cachedPolygon.getVertices()[0];
        proscenium[0] = proscenium[1] = initialPoint[0];
        proscenium[2] = proscenium[3] = initialPoint[1];
-       while ( isValid() ) {
+       while (isValid()) {
                GridHelpers::expandProscenium (proscenium, cachedPolygon);
                next();
        }
-       cout << "Proscenium: (" << proscenium[0] << ", " << proscenium[1] << ", " << proscenium[2] << ", " << proscenium[3] << ")" << endl;
+       cout << "Proscenium: (" << proscenium[0] << ", " << proscenium[1] << ", " << proscenium[2] << ", "
+            << proscenium[3] << ")" << endl;
 }
 
-real OccluderSource::averageOccluderArea() {
+real OccluderSource::averageOccluderArea()
+{