kannonier8/blender
1
0
Fork 0
forked from bartvdbraak/blender
Code Pull Requests Activity

Another "insanely" big code clean-up patch by Bastien Montagne, many thanks!

Browse Source
This commit is contained in:
Tamito Kajiyama 2012-12-22 18:25:01 +00:00
parent 8b57a67f3e
commit fa0211df26
32 changed files with 6234 additions and 5853 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

241
source/blender/freestyle/intern/geometry/BBox.h
View File

@ -1,141 +1,154 @@
//
// Filename : BBox.h
// Author(s) : Stephane Grabli
// Purpose : A class to hold a bounding box
// Date of creation : 22/05/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 __BBOX_H__
#define __BBOX_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 BBOX_H
# define BBOX_H
/** \file blender/freestyle/intern/geometry/BBox.h
* \ingroup freestyle
* \brief A class to hold a bounding box
* \author Stephane Grabli
* \date 22/05/2003
*/
template <class Point>
class BBox
{
public:
public:
inline BBox()
{
_empty = true;
}
inline BBox() {
_empty = true;
}
template <class T>
inline BBox(const T& min_in, const T& max_in) : _min(min_in), _max(max_in)
{
_empty = false;
}
template <class T>
inline BBox(const T& min_in, const T& max_in) : _min(min_in), _max(max_in) {
_empty = false;
}
template <class T>
inline BBox(const BBox<T>& b) : _min(b.getMin()), _max(b.getMax())
{
_empty = false;
}
template <class T>
inline BBox(const BBox<T>& b) : _min(b.getMin()), _max(b.getMax()) {
_empty = false;
}
template <class T>
inline void extendToContain(const T& p)
{
if (_empty) {
_min = p;
_max = p;
_empty = false;
return;
}
for (unsigned int i = 0; i < Point::dim(); i++) {
if (p[i] < _min[i])
_min[i] = p[i];
else if (p[i] > _max[i])
_max[i] = p[i];
}
_empty = false;
}
template <class T>
inline void extendToContain(const T& p) {
if (_empty) {
_min = p;
_max = p;
_empty = false;
return;
}
for (unsigned i = 0; i < Point::dim(); i++) {
if (p[i] < _min[i])
_min[i] = p[i];
else if (p[i] > _max[i])
_max[i] = p[i];
}
_empty = false;
}
inline void clear()
{
_empty = true;
}
inline void clear() {
_empty = true;
}
inline bool empty() const
{
return _empty;
}
inline bool empty() const {
return _empty;
}
inline const Point& getMin() const
{
return _min;
}
inline const Point& getMin() const {
return _min;
}
inline const Point& getMax() const
{
return _max;
}
inline const Point& getMax() const {
return _max;
}
inline BBox<Point>& operator=(const BBox<Point>& b)
{
_min = b.getMin();
_max = b.getMax();
_empty = false;
return *this;
}
inline BBox<Point>& operator=(const BBox<Point>& b) {
_min = b.getMin();
_max = b.getMax();
_empty = false;
return *this;
}
inline BBox<Point>& operator+=(const BBox<Point>& b)
{
if (_empty) {
_min = b.getMin();
_max = b.getMax();
_empty = false;
}
else {
for (unsigned int i = 0; i < Point::dim(); i++) {
if (b.getMin()[i] < _min[i])
_min[i] = b.getMin()[i];
if (b.getMax()[i] > _max[i])
_max[i] = b.getMax()[i];
}
}
return *this;
}
inline BBox<Point>& operator+=(const BBox<Point>& b) {
if (_empty) {
_min = b.getMin();
_max = b.getMax();
_empty = false;
}
else {
for (unsigned i = 0; i < Point::dim(); i++) {
if (b.getMin()[i] < _min[i])
_min[i] = b.getMin()[i];
if (b.getMax()[i] > _max[i])
_max[i] = b.getMax()[i];
}
}
return *this;
}
inline bool inside(const Point& p){
if(empty())
return false;
for (unsigned i = 0; i < Point::dim(); i++) {
if((_min[i]>p[i]) || (_max[i]<p[i]))
return false;
}
return true;
}
inline bool inside(const Point& p)
{
if (empty())
return false;
for (unsigned int i = 0; i < Point::dim(); i++) {
if ((_min[i]>p[i]) || (_max[i]<p[i]))
return false;
}
return true;
}
private:
Point _min;
Point _max;
bool _empty;
Point _min;
Point _max;
bool _empty;
};
template <class Point>
BBox<Point>& operator+(const BBox<Point> &b1, const BBox<Point> &b2)
{
Point new_min;
Point new_max;
Point new_min;
Point new_max;
for (unsigned i = 0; i < Point::dim(); i++) {
new_min[i] = b1.getMin()[i] < b2.getMin()[i] ? b1.getMin()[i] : b2.getMin()[i];
new_max[i] = b1.getMax()[i] > b2.getMax()[i] ? b1.getMax()[i] : b2.getMax()[i];
}
for (unsigned int i = 0; i < Point::dim(); i++) {
new_min[i] = b1.getMin()[i] < b2.getMin()[i] ? b1.getMin()[i] : b2.getMin()[i];
new_max[i] = b1.getMax()[i] > b2.getMax()[i] ? b1.getMax()[i] : b2.getMax()[i];
}
return BBox<Point>(new_min, new_max);
return BBox<Point>(new_min, new_max);
}
#endif // BBOX_H
#endif // __BBOX_H__

161
source/blender/freestyle/intern/geometry/Bezier.cpp
View File

@ -1,23 +1,36 @@
/*
* ***** 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/geometry/Bezier.cpp
* \ingroup freestyle
* \brief Class to define a Bezier curve of order 4.
* \author Stephane Grabli
* \date 04/06/2003
*/
#include "Bezier.h"
#include "FitCurve.h"
@ -34,85 +47,81 @@ BezierCurveSegment::~BezierCurveSegment()
void BezierCurveSegment::AddControlPoint(const Vec2d& iPoint)
{
_ControlPolygon.push_back(iPoint);
if(_ControlPolygon.size() == 4)
Build();
_ControlPolygon.push_back(iPoint);
if (_ControlPolygon.size() == 4)
Build();
}
void BezierCurveSegment::Build()
{
if(_ControlPolygon.size() != 4)
return;
if (_ControlPolygon.size() != 4)
return;
// Compute the rightmost part of the matrix:
vector<Vec2d>::const_iterator p0,p1,p2,p3;
p0 = _ControlPolygon.begin();
p1 = p0;++p1;
p2 = p1;++p2;
p3 = p2;++p3;
float x[4], y[4];
x[0] = -p0->x()+3*p1->x()-3*p2->x()+p3->x();
x[1] = 3*p0->x()-6*p1->x()+3*p2->x();
x[2] = -3*p0->x()+3*p1->x();
x[3] = p0->x();
// Compute the rightmost part of the matrix:
vector<Vec2d>::const_iterator p0,p1,p2,p3;
p0 = _ControlPolygon.begin();
p1 = p0;
++p1;
p2 = p1;
++p2;
p3 = p2;
++p3;
float x[4], y[4];
y[0] = -p0->y()+3*p1->y()-3*p2->y()+p3->y();
y[1] = 3*p0->y()-6*p1->y()+3*p2->y();
y[2] = -3*p0->y()+3*p1->y();
y[3] = p0->y();
x[0] = -p0->x() + 3 * p1->x() - 3 * p2->x() + p3->x();
x[1] = 3 * p0->x() - 6 * p1->x() + 3 * p2->x();
x[2] = -3 * p0->x() + 3 * p1->x();
x[3] = p0->x();
int nvertices = 12;
float increment = 1.0/(float)nvertices;
float t = 0.f;
for(int i=0; i<=nvertices; ++i)
{
_Vertices.push_back(Vec2d((x[3] + t*(x[2] + t*(x[1] + t*x[0]))),
(y[3] + t*(y[2] + t*(y[1] + t*y[0])))));
t+=increment;
}
y[0] = -p0->y() + 3 * p1->y() - 3 * p2->y() + p3->y();
y[1] = 3 * p0->y() - 6 * p1->y() + 3 * p2->y();
y[2] = -3 * p0->y() + 3 * p1->y();
y[3] = p0->y();
int nvertices = 12;
float increment = 1.0 / (float)nvertices;
float t = 0.0f;
for (int i = 0; i <= nvertices; ++i) {
_Vertices.push_back(Vec2d((x[3] + t * (x[2] + t * (x[1] + t * x[0]))),
(y[3] + t * (y[2] + t * (y[1] + t * y[0])))));
t += increment;
}
}
BezierCurve::BezierCurve()
{
_currentSegment = new BezierCurveSegment;
_currentSegment = new BezierCurveSegment;
}
BezierCurve::BezierCurve(vector<Vec2d>& iPoints, double error)
{
FitCurveWrapper fitcurve;
_currentSegment = new BezierCurveSegment;
vector<Vec2d> curve;
FitCurveWrapper fitcurve;
_currentSegment = new BezierCurveSegment;
vector<Vec2d> curve;
fitcurve.FitCurve(iPoints, curve, error);
int i=0;
vector<Vec2d>::iterator v,vend;
for(v=curve.begin(),vend=curve.end();
v!=vend;
++v)
{
if((i == 0) || (i%4 != 0))
AddControlPoint(*v);
++i;
}
fitcurve.FitCurve(iPoints, curve, error);
int i = 0;
vector<Vec2d>::iterator v,vend;
for (v = curve.begin(), vend = curve.end(); v != vend; ++v) {
if ((i == 0) || (i % 4 != 0))
AddControlPoint(*v);
++i;
}
}
BezierCurve::~BezierCurve()
{
if(_currentSegment)
delete _currentSegment;
if(_currentSegment)
delete _currentSegment;
}
void BezierCurve::AddControlPoint(const Vec2d& iPoint)
{
_ControlPolygon.push_back(iPoint);
_currentSegment->AddControlPoint(iPoint);
if(_currentSegment->size() == 4)
{
_Segments.push_back(_currentSegment);
_currentSegment = new BezierCurveSegment;
_currentSegment->AddControlPoint(iPoint);
}
_ControlPolygon.push_back(iPoint);
_currentSegment->AddControlPoint(iPoint);
if (_currentSegment->size() == 4) {
_Segments.push_back(_currentSegment);
_currentSegment = new BezierCurveSegment;
_currentSegment->AddControlPoint(iPoint);
}
}

121
source/blender/freestyle/intern/geometry/Bezier.h
View File

@ -1,73 +1,96 @@
//
// Filename : Bezier.h
// Author(s) : Stephane Grabli
// Purpose : Class to define a Bezier curve of order 4.
// Date of creation : 04/06/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 __BEZIER_H__
#define __BEZIER_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 BEZIER_H
# define BEZIER_H
/** \file blender/freestyle/intern/geometry/Bezier.h
* \ingroup freestyle
* \brief Class to define a Bezier curve of order 4.
* \author Stephane Grabli
* \date 04/06/2003
*/
#include <vector>
#include "../system/FreestyleConfig.h"
#include "Geom.h"
#include "../system/FreestyleConfig.h"
using namespace Geometry;
class LIB_GEOMETRY_EXPORT BezierCurveSegment
class LIB_GEOMETRY_EXPORT BezierCurveSegment
{
private:
std::vector<Vec2d> _ControlPolygon;
std::vector<Vec2d> _Vertices;
std::vector<Vec2d> _ControlPolygon;
std::vector<Vec2d> _Vertices;
public:
BezierCurveSegment();
virtual ~BezierCurveSegment();
BezierCurveSegment();
virtual ~BezierCurveSegment();
void AddControlPoint(const Vec2d& iPoint);
void Build();
inline int size() const {return _ControlPolygon.size();}
inline std::vector<Vec2d>& vertices() {return _Vertices;}
void AddControlPoint(const Vec2d& iPoint);
void Build();
inline int size() const
{
return _ControlPolygon.size();
}
inline std::vector<Vec2d>& vertices()
{
return _Vertices;
}
};
class LIB_GEOMETRY_EXPORT BezierCurve
{
private:
std::vector<Vec2d> _ControlPolygon;
std::vector<BezierCurveSegment*> _Segments;
BezierCurveSegment *_currentSegment;
std::vector<Vec2d> _ControlPolygon;
std::vector<BezierCurveSegment*> _Segments;
BezierCurveSegment *_currentSegment;
public:
BezierCurve();
BezierCurve(std::vector<Vec2d>& iPoints, double error=4.0);
virtual ~BezierCurve();
BezierCurve();
BezierCurve(std::vector<Vec2d>& iPoints, double error=4.0);
virtual ~BezierCurve();
void AddControlPoint(const Vec2d& iPoint);
std::vector<Vec2d>& controlPolygon() {return _ControlPolygon;}
std::vector<BezierCurveSegment*>& segments() {return _Segments;}
void AddControlPoint(const Vec2d& iPoint);
std::vector<Vec2d>& controlPolygon()
{
return _ControlPolygon;
}
std::vector<BezierCurveSegment*>& segments()
{
return _Segments;
}
};
#endif // BEZIER_H
#endif // __BEZIER_H__

119
source/blender/freestyle/intern/geometry/FastGrid.cpp
View File

@ -1,62 +1,83 @@
/*
* ***** 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/geometry/FastGrid.h
* \ingroup freestyle
* \brief Class to define a cell grid surrounding the bounding box of the scene
* \author Stephane Grabli
* \date 30/07/2002
*/
#include "FastGrid.h"
void FastGrid::clear() {
if(!_cells)
return;
void FastGrid::clear()
{
if (!_cells)
return;
for(unsigned i = 0; i < _cells_size; i++)
if (_cells[i])
delete _cells[i];
delete[] _cells;
_cells = NULL;
_cells_size = 0;
for (unsigned int i = 0; i < _cells_size; i++) {
if (_cells[i])
delete _cells[i];
}
delete[] _cells;
_cells = NULL;
_cells_size = 0;
Grid::clear();
Grid::clear();
}
void FastGrid::configure(const Vec3r& orig, const Vec3r& size, unsigned nb) {
Grid::configure(orig, size, nb);
_cells_size = _cells_nb[0] * _cells_nb[1] * _cells_nb[2];
_cells = new Cell*[_cells_size];
memset(_cells, 0, _cells_size * sizeof(*_cells));
void FastGrid::configure(const Vec3r& orig, const Vec3r& size, unsigned nb)
{
Grid::configure(orig, size, nb);
_cells_size = _cells_nb[0] * _cells_nb[1] * _cells_nb[2];
_cells = new Cell*[_cells_size];
memset(_cells, 0, _cells_size * sizeof(*_cells));
}
Cell* FastGrid::getCell(const Vec3u& p) {
//cout << _cells<< " "<< p << " " <<_cells_nb[0]<<"-"<< _cells_nb[1]<<"-"<< _cells_nb[2]<< " "<<_cells_size<< endl;
assert(_cells||("_cells is a null pointer"));
assert((_cells_nb[0] * (p[2] * _cells_nb[1] + p[1]) + p[0])<_cells_size);
assert(p[0]<_cells_nb[0]);
assert(p[1]<_cells_nb[1]);
assert(p[2]<_cells_nb[2]);
return _cells[_cells_nb[0] * (p[2] * _cells_nb[1] + p[1]) + p[0]];
Cell *FastGrid::getCell(const Vec3u& p)
{
#if 0
cout << _cells << " " << p << " " << _cells_nb[0] << "-" << _cells_nb[1] << "-" << _cells_nb[2]
<< " " << _cells_size << endl;
#endif
assert(_cells || ("_cells is a null pointer"));
assert((_cells_nb[0] * (p[2] * _cells_nb[1] + p[1]) + p[0]) < _cells_size);
assert(p[0] < _cells_nb[0]);
assert(p[1] < _cells_nb[1]);
assert(p[2] < _cells_nb[2]);
return _cells[_cells_nb[0] * (p[2] * _cells_nb[1] + p[1]) + p[0]];
}
void FastGrid::fillCell(const Vec3u& p, Cell& cell) {
assert(_cells||("_cells is a null pointer"));
assert((_cells_nb[0] * (p[2] * _cells_nb[1] + p[1]) + p[0])<_cells_size);
assert(p[0]<_cells_nb[0]);
assert(p[1]<_cells_nb[1]);
assert(p[2]<_cells_nb[2]);
_cells[_cells_nb[0] * (p[2] * _cells_nb[1] + p[1]) + p[0]] = &cell;
void FastGrid::fillCell(const Vec3u& p, Cell& cell)
{
assert(_cells || ("_cells is a null pointer"));
assert((_cells_nb[0] * (p[2] * _cells_nb[1] + p[1]) + p[0]) < _cells_size);
assert(p[0] < _cells_nb[0]);
assert(p[1] < _cells_nb[1]);
assert(p[2] < _cells_nb[2]);
_cells[_cells_nb[0] * (p[2] * _cells_nb[1] + p[1]) + p[0]] = &cell;
}

151
source/blender/freestyle/intern/geometry/FastGrid.h
View File

@ -1,85 +1,86 @@
//
// Filename : FastGrid.h
// Author(s) : Stephane Grabli
// Purpose : Class to define a cell grid surrounding the
// bounding box of the scene
// Date of creation : 30/07/2002
//
///////////////////////////////////////////////////////////////////////////////
//
// 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 FASTGRID_H
# define FASTGRID_H
# include "Grid.h"
# include <cassert>
/*! Class to define a regular grid used for ray
* casting computations
* We don't use a hashtable here. The grid is
* explicitly stored for faster computations.
* However, this might result in significant
* increase in memory usage (compared to the regular grid)
/*
* ***** 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 __FASTGRID_H__
#define __FASTGRID_H__
/** \file blender/freestyle/intern/geometry/FastGrid.h
* \ingroup freestyle
* \brief Class to define a cell grid surrounding the bounding box of the scene
* \author Stephane Grabli
* \date 30/07/2002
*/
#include <cassert>
#include "Grid.h"
/*! Class to define a regular grid used for ray casting computations
* We don't use a hashtable here. The grid is explicitly stored for faster computations.
* However, this might result in significant increase in memory usage (compared to the regular grid)
*/
class LIB_GEOMETRY_EXPORT FastGrid : public Grid
{
public:
public:
FastGrid() : Grid()
{
_cells = NULL;
_cells_size = 0;
}
FastGrid() : Grid() {
_cells = NULL;
_cells_size = 0;
}
virtual ~FastGrid() {
clear();
}
virtual ~FastGrid()
{
clear();
}
/*! clears the grid
* Deletes all the cells, clears the hashtable,
* resets size, size of cell, number of cells.
*/
virtual void clear();
/*! Sets the different parameters of the grid
* orig
* The grid origin
* size
* The grid's dimensions
* nb
* The number of cells of the grid
*/
virtual void configure(const Vec3r& orig, const Vec3r& size, unsigned nb);
/*! returns the cell whose coordinates are pased as argument */
Cell* getCell(const Vec3u& p) ;
/*! Fills the case p with the cell iCell */
virtual void fillCell(const Vec3u& p, Cell& cell);
/*! clears the grid
* Deletes all the cells, clears the hashtable, resets size, size of cell, number of cells.
*/
virtual void clear();
/*! Sets the different parameters of the grid
* orig
* The grid origin
* size
* The grid's dimensions
* nb
* The number of cells of the grid
*/
virtual void configure(const Vec3r& orig, const Vec3r& size, unsigned nb);
/*! returns the cell whose coordinates are pased as argument */
Cell* getCell(const Vec3u& p);
/*! Fills the case p with the cell iCell */
virtual void fillCell(const Vec3u& p, Cell& cell);
protected:
Cell** _cells;
unsigned _cells_size;
Cell **_cells;
unsigned _cells_size;
};
#endif // FASTGRID_H
#endif // __FASTGRID_H__

737
source/blender/freestyle/intern/geometry/FitCurve.cpp
View File

@ -1,33 +1,49 @@
/*
* ***** 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/geometry/FitCurve.cpp
* \ingroup freestyle
* \brief An Algorithm for Automatically Fitting Digitized Curves by Philip J. Schneider,
* \brief from "Graphics Gems", Academic Press, 1990
* \author Stephane Grabli
* \date 06/06/2003
*/
#include <cstdlib> // for malloc and free
#include <stdio.h>
#include <math.h>
#include "FitCurve.h"
using namespace std;
typedef Vector2 *BezierCurve;
// XXX Do we need "#ifdef __cplusplus" at all here???
#ifdef __cplusplus
extern "C"
{
@ -46,379 +62,367 @@ static Vector2 ComputeLeftTangent(Vector2 *d, int end);
static Vector2 ComputeLeftTangent(Vector2 *d, int end);
static double ComputeMaxError(Vector2 *d, int first, int last, BezierCurve bezCurve, double *u, int *splitPoint);
static double *ChordLengthParameterize(Vector2 *d, int first, int last);
static BezierCurve GenerateBezier(Vector2 *d, int first, int last, double *uPrime, Vector2 tHat1, Vector2 tHat2);
static BezierCurve GenerateBezier(Vector2 *d, int first, int last, double *uPrime, Vector2 tHat1, Vector2 tHat2);
static Vector2 V2AddII(Vector2 a, Vector2 b);
static Vector2 V2ScaleIII(Vector2 v, double s);
static Vector2 V2SubII(Vector2 a, Vector2 b);
#define MAXPOINTS 1000 /* The most points you can have */
#define MAXPOINTS 1000 /* The most points you can have */
/* returns squared length of input vector */
static double V2SquaredLength(Vector2 *a)
{ return(((*a)[0] * (*a)[0])+((*a)[1] * (*a)[1]));
/* returns squared length of input vector */
static double V2SquaredLength(Vector2 *a)
{
return (((*a)[0] * (*a)[0]) + ((*a)[1] * (*a)[1]));
}
/* returns length of input vector */
static double V2Length(Vector2 *a)
{
return(sqrt(V2SquaredLength(a)));
return (sqrt(V2SquaredLength(a)));
}
static Vector2 *V2Scale(Vector2 *v, double newlen)
static Vector2 *V2Scale(Vector2 *v, double newlen)
{
double len = V2Length(v);
if (len != 0.0) { (*v)[0] *= newlen/len; (*v)[1] *= newlen/len; }
return(v);
double len = V2Length(v);
if (len != 0.0) {
(*v)[0] *= newlen / len;
(*v)[1] *= newlen / len;
}
return v;
}
/* return the dot product of vectors a and b */
static double V2Dot(Vector2 *a, Vector2 *b)
static double V2Dot(Vector2 *a, Vector2 *b)
{
return(((*a)[0]*(*b)[0])+((*a)[1]*(*b)[1]));
return (((*a)[0] * (*b)[0]) + ((*a)[1] * (*b)[1]));
}
/* return the distance between two points */
static double V2DistanceBetween2Points(Vector2 *a, Vector2 *b)
{
double dx = (*a)[0] - (*b)[0];
double dy = (*a)[1] - (*b)[1];
return(sqrt((dx*dx)+(dy*dy)));
double dx = (*a)[0] - (*b)[0];
double dy = (*a)[1] - (*b)[1];
return (sqrt((dx * dx) + (dy * dy)));
}
/* return vector sum c = a+b */
static Vector2 *V2Add(Vector2 *a, Vector2 *b, Vector2 *c)
{
(*c)[0] = (*a)[0]+(*b)[0]; (*c)[1] = (*a)[1]+(*b)[1];
return(c);
(*c)[0] = (*a)[0] + (*b)[0];
(*c)[1] = (*a)[1] + (*b)[1];
return c;
}
/* normalizes the input vector and returns it */
static Vector2 *V2Normalize(Vector2 *v)
static Vector2 *V2Normalize(Vector2 *v)
{
double len = V2Length(v);
if (len != 0.0) { (*v)[0] /= len; (*v)[1] /= len; }
return(v);
double len = V2Length(v);
if (len != 0.0) {
(*v)[0] /= len;
(*v)[1] /= len;
}
return v;
}
/* negates the input vector and returns it */
static Vector2 *V2Negate(Vector2 *v)
static Vector2 *V2Negate(Vector2 *v)
{
(*v)[0] = -(*v)[0]; (*v)[1] = -(*v)[1];
return(v);
(*v)[0] = -(*v)[0];
(*v)[1] = -(*v)[1];
return v;
}
/*
* GenerateBezier :
/* GenerateBezier:
* Use least-squares method to find Bezier control points for region.
*
* Vector2 *d; Array of digitized points
* int first, last; Indices defining region
* double *uPrime; Parameter values for region
* Vector2 tHat1, tHat2; Unit tangents at endpoints
*/
static BezierCurve GenerateBezier(Vector2 *d, int first, int last, double *uPrime, Vector2 tHat1, Vector2 tHat2)
// Vector2 *d; /* Array of digitized points */
// int first, last; /* Indices defining region */
// double *uPrime; /* Parameter values for region */
// Vector2 tHat1, tHat2; /* Unit tangents at endpoints */
{
int i;
Vector2 A[MAXPOINTS][2]; /* Precomputed rhs for eqn */
int nPts; /* Number of pts in sub-curve */
double C[2][2]; /* Matrix C */
double X[2]; /* Matrix X */
double det_C0_C1, /* Determinants of matrices */
det_C0_X,
det_X_C1;
double alpha_l, /* Alpha values, left and right */
alpha_r;
Vector2 tmp; /* Utility variable */
BezierCurve bezCurve; /* RETURN bezier curve ctl pts */
int i;
Vector2 A[MAXPOINTS][2]; /* Precomputed rhs for eqn */
int nPts; /* Number of pts in sub-curve */
double C[2][2]; /* Matrix C */
double X[2]; /* Matrix X */
double det_C0_C1; /* Determinants of matrices */
double det_C0_X;
double det_X_C1;
double alpha_l; /* Alpha values, left and right */
double alpha_r;
Vector2 tmp; /* Utility variable */
BezierCurve bezCurve; /* RETURN bezier curve ctl pts */
bezCurve = (Vector2 *)malloc(4 * sizeof(Vector2));
nPts = last - first + 1;
bezCurve = (Vector2*)malloc(4 * sizeof(Vector2));
nPts = last - first + 1;
/* Compute the A's */
for (i = 0; i < nPts; i++) {
Vector2 v1, v2;
/* Compute the A's */
for (i = 0; i < nPts; i++) {
Vector2 v1, v2;
v1 = tHat1;
v2 = tHat2;
V2Scale(&v1, B1(uPrime[i]));
V2Scale(&v2, B2(uPrime[i]));
A[i][0] = v1;
A[i][1] = v2;
}
}
/* Create the C and X matrices */
C[0][0] = 0.0;
C[0][1] = 0.0;
C[1][0] = 0.0;
C[1][1] = 0.0;
X[0] = 0.0;
X[1] = 0.0;
for (i = 0; i < nPts; i++) {
C[0][0] += V2Dot(&A[i][0], &A[i][0]);
/* Create the C and X matrices */
C[0][0] = 0.0;
C[0][1] = 0.0;
C[1][0] = 0.0;
C[1][1] = 0.0;
X[0] = 0.0;
X[1] = 0.0;
for (i = 0; i < nPts; i++) {
C[0][0] += V2Dot(&A[i][0], &A[i][0]);
C[0][1] += V2Dot(&A[i][0], &A[i][1]);
/* C[1][0] += V2Dot(&A[i][0], &A[i][1]);*/
// C[1][0] += V2Dot(&A[i][0], &A[i][1]);
C[1][0] = C[0][1];
C[1][1] += V2Dot(&A[i][1], &A[i][1]);
tmp = V2SubII(d[first + i],
V2AddII(
V2ScaleIII(d[first], B0(uPrime[i])),
V2AddII(
V2ScaleIII(d[first], B1(uPrime[i])),
V2AddII(
V2ScaleIII(d[last], B2(uPrime[i])),
V2ScaleIII(d[last], B3(uPrime[i]))))));
V2AddII(V2ScaleIII(d[first], B0(uPrime[i])),
V2AddII(V2ScaleIII(d[first], B1(uPrime[i])),
V2AddII(V2ScaleIII(d[last], B2(uPrime[i])),
V2ScaleIII(d[last], B3(uPrime[i]))
)
)
)
);
X[0] += V2Dot(&((A[i])[0]), &tmp);
X[1] += V2Dot(&((A[i])[1]), &tmp);
}
X[0] += V2Dot(&((A[i])[0]), &tmp);
X[1] += V2Dot(&((A[i])[1]), &tmp);
}
/* Compute the determinants of C and X */
det_C0_C1 = C[0][0] * C[1][1] - C[1][0] * C[0][1];
det_C0_X = C[0][0] * X[1] - C[0][1] * X[0];
det_X_C1 = X[0] * C[1][1] - X[1] * C[0][1];
/* Compute the determinants of C and X */
det_C0_C1 = C[0][0] * C[1][1] - C[1][0] * C[0][1];
det_C0_X = C[0][0] * X[1] - C[0][1] * X[0];
det_X_C1 = X[0] * C[1][1] - X[1] * C[0][1];
/* Finally, derive alpha values */
if (det_C0_C1 == 0.0) {
det_C0_C1 = (C[0][0] * C[1][1]) * 10e-12;
}
alpha_l = det_X_C1 / det_C0_C1;
alpha_r = det_C0_X / det_C0_C1;
/* Finally, derive alpha values */
if (det_C0_C1 == 0.0) {
det_C0_C1 = (C[0][0] * C[1][1]) * 10.0e-12;
}
alpha_l = det_X_C1 / det_C0_C1;
alpha_r = det_C0_X / det_C0_C1;
/* If alpha negative, use the Wu/Barsky heuristic (see text) */
/* (if alpha is 0, you get coincident control points that lead to
* divide by zero in any subsequent NewtonRaphsonRootFind() call. */
if (alpha_l < 1.0e-6 || alpha_r < 1.0e-6) {
double dist = V2DistanceBetween2Points(&d[last], &d[first]) /
3.0;
/* If alpha negative, use the Wu/Barsky heuristic (see text) (if alpha is 0, you get coincident control points
* that lead to divide by zero in any subsequent NewtonRaphsonRootFind() call).
*/
if (alpha_l < 1.0e-6 || alpha_r < 1.0e-6) {
double dist = V2DistanceBetween2Points(&d[last], &d[first]) / 3.0;
bezCurve[0] = d[first];
bezCurve[3] = d[last];
V2Add(&(bezCurve[0]), V2Scale(&(tHat1), dist), &(bezCurve[1]));
V2Add(&(bezCurve[3]), V2Scale(&(tHat2), dist), &(bezCurve[2]));
return (bezCurve);
}
return bezCurve;
}
/* First and last control points of the Bezier curve are */
/* positioned exactly at the first and last data points */
/* Control points 1 and 2 are positioned an alpha distance out */
/* on the tangent vectors, left and right, respectively */
bezCurve[0] = d[first];
bezCurve[3] = d[last];
V2Add(&bezCurve[0], V2Scale(&tHat1, alpha_l), &bezCurve[1]);
V2Add(&bezCurve[3], V2Scale(&tHat2, alpha_r), &bezCurve[2]);
return (bezCurve);
/* First and last control points of the Bezier curve are positioned exactly at the first and last data points
* Control points 1 and 2 are positioned an alpha distance out on the tangent vectors, left and right, respectively
*/
bezCurve[0] = d[first];
bezCurve[3] = d[last];
V2Add(&bezCurve[0], V2Scale(&tHat1, alpha_l), &bezCurve[1]);
V2Add(&bezCurve[3], V2Scale(&tHat2, alpha_r), &bezCurve[2]);
return (bezCurve);
}
/*
* Reparameterize:
* Given set of points and their parameterization, try to find
* a better parameterization.
*
* Given set of points and their parameterization, try to find a better parameterization.
* Vector2 *d; Array of digitized points
* int first, last; Indices defining region
* double *u; Current parameter values
* BezierCurve bezCurve; Current fitted curve
*/
static double *Reparameterize(Vector2 *d, int first, int last, double *u, BezierCurve bezCurve)
// Vector2 *d; /* Array of digitized points */
// int first, last; /* Indices defining region */
// double *u; /* Current parameter values */
// BezierCurve bezCurve; /* Current fitted curve */
{
int nPts = last-first+1;
int i;
double *uPrime; /* New parameter values */
int nPts = last - first + 1;
int i;
double *uPrime; /* New parameter values */
uPrime = (double *)malloc(nPts * sizeof(double));
for (i = first; i <= last; i++) {
uPrime[i-first] = NewtonRaphsonRootFind(bezCurve, d[i], u[i-
first]);
}
return (uPrime);
uPrime = (double*)malloc(nPts * sizeof(double));
for (i = first; i <= last; i++) {
uPrime[i-first] = NewtonRaphsonRootFind(bezCurve, d[i], u[i - first]);
}
return (uPrime);
}
/*
* NewtonRaphsonRootFind :
* Use Newton-Raphson iteration to find better root.
* NewtonRaphsonRootFind:
* Use Newton-Raphson iteration to find better root.
* BezierCurve Q; Current fitted curve
* Vector2 P; Digitized point
* double u; Parameter value for "P"
*/
static double NewtonRaphsonRootFind(BezierCurve Q, Vector2 P, double u)
// BezierCurve Q; /* Current fitted curve */
// Vector2 P; /* Digitized point */
// double u; /* Parameter value for "P" */
{
double numerator, denominator;
Vector2 Q1[3], Q2[2]; /* Q' and Q'' */
Vector2 Q_u, Q1_u, Q2_u; /*u evaluated at Q, Q', & Q'' */
double uPrime; /* Improved u */
int i;
/* Compute Q(u) */
Q_u = BezierII(3, Q, u);
/* Generate control vertices for Q' */
for (i = 0; i <= 2; i++) {
Q1[i][0] = (Q[i+1][0] - Q[i][0]) * 3.0;
Q1[i][1] = (Q[i+1][1] - Q[i][1]) * 3.0;
}
/* Generate control vertices for Q'' */
for (i = 0; i <= 1; i++) {
Q2[i][0] = (Q1[i+1][0] - Q1[i][0]) * 2.0;
Q2[i][1] = (Q1[i+1][1] - Q1[i][1]) * 2.0;
}
/* Compute Q'(u) and Q''(u) */
Q1_u = BezierII(2, Q1, u);
Q2_u = BezierII(1, Q2, u);
/* Compute f(u)/f'(u) */
numerator = (Q_u[0] - P[0]) * (Q1_u[0]) + (Q_u[1] - P[1]) * (Q1_u[1]);
denominator = (Q1_u[0]) * (Q1_u[0]) + (Q1_u[1]) * (Q1_u[1]) +
(Q_u[0] - P[0]) * (Q2_u[0]) + (Q_u[1] - P[1]) * (Q2_u[1]);
/* u = u - f(u)/f'(u) */
if(denominator == 0) // FIXME
return u;
uPrime = u - (numerator/denominator);
return (uPrime);
double numerator, denominator;
Vector2 Q1[3], Q2[2]; /* Q' and Q'' */
Vector2 Q_u, Q1_u, Q2_u; /* u evaluated at Q, Q', & Q'' */
double uPrime; /* Improved u */
int i;
/* Compute Q(u) */
Q_u = BezierII(3, Q, u);
/* Generate control vertices for Q' */
for (i = 0; i <= 2; i++) {
Q1[i][0] = (Q[i + 1][0] - Q[i][0]) * 3.0;
Q1[i][1] = (Q[i + 1][1] - Q[i][1]) * 3.0;
}
/* Generate control vertices for Q'' */
for (i = 0; i <= 1; i++) {
Q2[i][0] = (Q1[i + 1][0] - Q1[i][0]) * 2.0;
Q2[i][1] = (Q1[i + 1][1] - Q1[i][1]) * 2.0;
}
/* Compute Q'(u) and Q''(u) */
Q1_u = BezierII(2, Q1, u);
Q2_u = BezierII(1, Q2, u);
/* Compute f(u)/f'(u) */
numerator = (Q_u[0] - P[0]) * (Q1_u[0]) + (Q_u[1] - P[1]) * (Q1_u[1]);
denominator = (Q1_u[0]) * (Q1_u[0]) + (Q1_u[1]) * (Q1_u[1]) +
(Q_u[0] - P[0]) * (Q2_u[0]) + (Q_u[1] - P[1]) * (Q2_u[1]);
/* u = u - f(u)/f'(u) */
if (denominator == 0) // FIXME
return u;
uPrime = u - (numerator / denominator);
return uPrime;
}
/*
* Bezier :
* Evaluate a Bezier curve at a particular parameter value
*
* Bezier:
* Evaluate a Bezier curve at a particular parameter value
* int degree; The degree of the bezier curve
* Vector2 *V; Array of control points
* double t; Parametric value to find point for
*/
static Vector2 BezierII(int degree, Vector2 *V, double t)
// int degree; /* The degree of the bezier curve */
// Vector2 *V; /* Array of control points */
// double t; /* Parametric value to find point for */
{
int i, j;
Vector2 Q; /* Point on curve at parameter t */
Vector2 *Vtemp; /* Local copy of control points */
int i, j;
Vector2 Q; /* Point on curve at parameter t */
Vector2 *Vtemp; /* Local copy of control points */
/* Copy array */
Vtemp = (Vector2 *)malloc((unsigned)((degree+1)
* sizeof (Vector2)));
for (i = 0; i <= degree; i++) {
/* Copy array */
Vtemp = (Vector2*)malloc((unsigned)((degree + 1) * sizeof (Vector2)));
for (i = 0; i <= degree; i++) {
Vtemp[i] = V[i];
}
}
/* Triangle computation */
for (i = 1; i <= degree; i++) {
/* Triangle computation */
for (i = 1; i <= degree; i++) {
for (j = 0; j <= degree-i; j++) {
Vtemp[j][0] = (1.0 - t) * Vtemp[j][0] + t * Vtemp[j+1][0];
Vtemp[j][1] = (1.0 - t) * Vtemp[j][1] + t * Vtemp[j+1][1];
Vtemp[j][0] = (1.0 - t) * Vtemp[j][0] + t * Vtemp[j + 1][0];
Vtemp[j][1] = (1.0 - t) * Vtemp[j][1] + t * Vtemp[j + 1][1];
}
}
}
Q = Vtemp[0];
free((void *)Vtemp);
return Q;
Q = Vtemp[0];
free((void*)Vtemp);
return Q;
}
/*
* B0, B1, B2, B3 :
* Bezier multipliers
* B0, B1, B2, B3:
* Bezier multipliers
*/
static double B0(double u)
{
double tmp = 1.0 - u;
return (tmp * tmp * tmp);
double tmp = 1.0 - u;
return (tmp * tmp * tmp);
}
static double B1(double u)
{
double tmp = 1.0 - u;
return (3 * u * (tmp * tmp));
double tmp = 1.0 - u;
return (3 * u * (tmp * tmp));
}
static double B2(double u)
{
double tmp = 1.0 - u;
return (3 * u * u * tmp);
double tmp = 1.0 - u;
return (3 * u * u * tmp);
}
static double B3(double u)
{
return (u * u * u);
return (u * u * u);
}
/*
* ComputeLeftTangent, ComputeRightTangent, ComputeCenterTangent :
*Approximate unit tangents at endpoints and "center" of digitized curve
* ComputeLeftTangent, ComputeRightTangent, ComputeCenterTangent:
* Approximate unit tangents at endpoints and "center" of digitized curve
*/
/* Vector2 *d; Digitized points
* int end; Index to "left" end of region
*/
static Vector2 ComputeLeftTangent(Vector2 *d, int end)
// Vector2 *d; /* Digitized points*/
// int end; /* Index to "left" end of region */
{
Vector2 tHat1;
tHat1 = V2SubII(d[end+1], d[end]);
tHat1 = *V2Normalize(&tHat1);
return tHat1;
Vector2 tHat1;
tHat1 = V2SubII(d[end + 1], d[end]);
tHat1 = *V2Normalize(&tHat1);
return tHat1;
}
/* Vector2 *d; Digitized points
* int end; Index to "right" end of region
*/
static Vector2 ComputeRightTangent(Vector2 *d, int end)
// Vector2 *d; /* Digitized points */
// int end; /* Index to "right" end of region */
{
Vector2 tHat2;
tHat2 = V2SubII(d[end-1], d[end]);
tHat2 = *V2Normalize(&tHat2);
return tHat2;
Vector2 tHat2;
tHat2 = V2SubII(d[end - 1], d[end]);
tHat2 = *V2Normalize(&tHat2);
return tHat2;
}
/* Vector2 *d; Digitized points
* int end; Index to point inside region
*/
static Vector2 ComputeCenterTangent(Vector2 *d, int center)
// Vector2 *d; /* Digitized points */
// int center; /* Index to point inside region */
{
Vector2 V1, V2, tHatCenter;
Vector2 V1, V2, tHatCenter;
V1 = V2SubII(d[center-1], d[center]);
V2 = V2SubII(d[center], d[center+1]);
tHatCenter[0] = (V1[0] + V2[0])/2.0;
tHatCenter[1] = (V1[1] + V2[1])/2.0;
tHatCenter = *V2Normalize(&tHatCenter);
return tHatCenter;
V1 = V2SubII(d[center - 1], d[center]);
V2 = V2SubII(d[center], d[center + 1]);
tHatCenter[0] = (V1[0] + V2[0]) / 2.0;
tHatCenter[1] = (V1[1] + V2[1]) / 2.0;
tHatCenter = *V2Normalize(&tHatCenter);
return tHatCenter;
}
/*
* ChordLengthParameterize :
* Assign parameter values to digitized points
* using relative distances between points.
* ChordLengthParameterize:
* Assign parameter values to digitized points using relative distances between points.
* Vector2 *d; Array of digitized points
* int first, last; Indices defining region
*/
static double *ChordLengthParameterize(Vector2 *d, int first, int last)
// Vector2 *d; /* Array of digitized points */
// int first, last; /* Indices defining region */
{
int i;
double *u; /* Parameterization */
int i;
double *u; /* Parameterization */
u = (double *)malloc((unsigned)(last-first+1) * sizeof(double));
u = (double*)malloc((unsigned)(last - first + 1) * sizeof(double));
u[0] = 0.0;
for (i = first+1; i <= last; i++) {
u[i-first] = u[i-first-1] +
V2DistanceBetween2Points(&d[i], &d[i-1]);
}
u[0] = 0.0;
for (i = first + 1; i <= last; i++) {
u[i - first] = u[i - first - 1] + V2DistanceBetween2Points(&d[i], &d[i - 1]);
}
for (i = first + 1; i <= last; i++) {
u[i-first] = u[i-first] / u[last-first];
}
for (i = first + 1; i <= last; i++) {
u[i - first] = u[i - first] / u[last - first];
}
return(u);
return u;
}
@ -426,53 +430,57 @@ static double *ChordLengthParameterize(Vector2 *d, int first, int last)
/*
* ComputeMaxError :
* Find the maximum squared distance of digitized points
* to fitted curve.
*/
* Find the maximum squared distance of digitized points to fitted curve.
* Vector2 *d; Array of digitized points
* int first, last; Indices defining region
* BezierCurve bezCurve; Fitted Bezier curve
* double *u; Parameterization of points
* int *splitPoint; Point of maximum error
*/
static double ComputeMaxError(Vector2 *d, int first, int last, BezierCurve bezCurve, double *u, int *splitPoint)
// Vector2 *d; /* Array of digitized points */
// int first, last; /* Indices defining region */
// BezierCurve bezCurve; /* Fitted Bezier curve */
// double *u; /* Parameterization of points */
// int *splitPoint; /* Point of maximum error */
{
int i;
double maxDist; /* Maximum error */
double dist; /* Current error */
Vector2 P; /* Point on curve */
Vector2 v; /* Vector from point to curve */
int i;
double maxDist; /* Maximum error */
double dist; /* Current error */
Vector2 P; /* Point on curve */
Vector2 v; /* Vector from point to curve */
*splitPoint = (last - first + 1)/2;
maxDist = 0.0;
for (i = first + 1; i < last; i++) {
P = BezierII(3, bezCurve, u[i-first]);
*splitPoint = (last - first + 1) / 2;
maxDist = 0.0;
for (i = first + 1; i < last; i++) {
P = BezierII(3, bezCurve, u[i - first]);
v = V2SubII(P, d[i]);
dist = V2SquaredLength(&v);
if (dist >= maxDist) {
maxDist = dist;
*splitPoint = i;
maxDist = dist;
*splitPoint = i;
}
}
return (maxDist);
}
return maxDist;
}
static Vector2 V2AddII(Vector2 a, Vector2 b)
{
Vector2 c;
c[0] = a[0] + b[0]; c[1] = a[1] + b[1];
return (c);
Vector2 c;
c[0] = a[0] + b[0];
c[1] = a[1] + b[1];
return c;
}
static Vector2 V2ScaleIII(Vector2 v, double s)
{
Vector2 result;
result[0] = v[0] * s; result[1] = v[1] * s;
return (result);
Vector2 result;
result[0] = v[0] * s;
result[1] = v[1] * s;
return result;
}
static Vector2 V2SubII(Vector2 a, Vector2 b)
{
Vector2 c;
c[0] = a[0] - b[0]; c[1] = a[1] - b[1];
return (c);
Vector2 c;
c[0] = a[0] - b[0];
c[1] = a[1] - b[1];
return c;
}
#ifdef __cplusplus
@ -488,116 +496,107 @@ FitCurveWrapper::FitCurveWrapper()
FitCurveWrapper::~FitCurveWrapper()
{
_vertices.clear();
_vertices.clear();
}
void FitCurveWrapper::DrawBezierCurve(int n, Vector2 *curve )
void FitCurveWrapper::DrawBezierCurve(int n, Vector2 *curve)
{
for(int i=0; i<n+1; ++i)
_vertices.push_back(curve[i]);
for (int i = 0; i < n + 1; ++i)
_vertices.push_back(curve[i]);
}
void FitCurveWrapper::FitCurve(vector<Vec2d>& data, vector<Vec2d>& oCurve, double error)
{
int size = data.size();
Vector2 *d = new Vector2[size];
for(int i=0; i<size; ++i)
{
d[i][0] = data[i][0];
d[i][1] = data[i][1];
}
int size = data.size();
Vector2 *d = new Vector2[size];
for (int i = 0; i < size; ++i) {
d[i][0] = data[i][0];
d[i][1] = data[i][1];
}
FitCurve(d,size,error);
FitCurve(d, size, error);
// copy results
for(vector<Vector2>::iterator v=_vertices.begin(), vend=_vertices.end();
v!=vend;
++v)
{
oCurve.push_back(Vec2d(v->x(), v->y())) ;
}
// copy results
for (vector<Vector2>::iterator v = _vertices.begin(), vend = _vertices.end(); v != vend; ++v) {
oCurve.push_back(Vec2d(v->x(), v->y())) ;
}
}
void FitCurveWrapper::FitCurve(Vector2 *d, int nPts, double error)
{
Vector2 tHat1, tHat2; /* Unit tangent vectors at endpoints */
Vector2 tHat1, tHat2; /* Unit tangent vectors at endpoints */
tHat1 = ComputeLeftTangent(d, 0);
tHat2 = ComputeRightTangent(d, nPts - 1);
FitCubic(d, 0, nPts - 1, tHat1, tHat2, error);
tHat1 = ComputeLeftTangent(d, 0);
tHat2 = ComputeRightTangent(d, nPts - 1);
FitCubic(d, 0, nPts - 1, tHat1, tHat2, error);
}
void FitCurveWrapper::FitCubic(Vector2 *d, int first, int last, Vector2 tHat1, Vector2 tHat2, double error)
{
BezierCurve bezCurve; /*Control points of fitted Bezier curve*/
double *u; /* Parameter values for point */
double *uPrime; /* Improved parameter values */
double maxError; /* Maximum fitting error */
int splitPoint; /* Point to split point set at */
int nPts; /* Number of points in subset */
double iterationError; /*Error below which you try iterating */
int maxIterations = 4; /* Max times to try iterating */
Vector2 tHatCenter; /* Unit tangent vector at splitPoint */
int i;
BezierCurve bezCurve; /* Control points of fitted Bezier curve */
double *u; /* Parameter values for point */
double *uPrime; /* Improved parameter values */
double maxError; /* Maximum fitting error */
int splitPoint; /* Point to split point set at */
int nPts; /* Number of points in subset */
double iterationError; /* Error below which you try iterating */
int maxIterations = 4; /* Max times to try iterating */
Vector2 tHatCenter; /* Unit tangent vector at splitPoint */
int i;
iterationError = error * error;
nPts = last - first + 1;
iterationError = error * error;
nPts = last - first + 1;
/* Use heuristic if region only has two points in it */
if (nPts == 2) {
double dist = V2DistanceBetween2Points(&d[last], &d[first]) / 3.0;
/* Use heuristic if region only has two points in it */
if (nPts == 2) {
double dist = V2DistanceBetween2Points(&d[last], &d[first]) / 3.0;
bezCurve = (Vector2 *)malloc(4 * sizeof(Vector2));
bezCurve = (Vector2*)malloc(4 * sizeof(Vector2));
bezCurve[0] = d[first];
bezCurve[3] = d[last];
V2Add(&bezCurve[0], V2Scale(&tHat1, dist), &bezCurve[1]);
V2Add(&bezCurve[3], V2Scale(&tHat2, dist), &bezCurve[2]);
DrawBezierCurve(3, bezCurve);
free((void *)bezCurve);
free((void*)bezCurve);
return;
}
/* Parameterize points, and attempt to fit curve */
u = ChordLengthParameterize(d, first, last);
bezCurve = GenerateBezier(d, first, last, u, tHat1, tHat2);
/* Find max deviation of points to fitted curve */
maxError = ComputeMaxError(d, first, last, bezCurve, u, &splitPoint);
if (maxError < error) {
DrawBezierCurve(3, bezCurve);
free((void *)u);
free((void *)bezCurve);
return;
}
/* If error not too large, try some reparameterization */
/* and iteration */
if (maxError < iterationError) {
for (i = 0; i < maxIterations; i++) {
uPrime = Reparameterize(d, first, last, u, bezCurve);
bezCurve = GenerateBezier(d, first, last, uPrime, tHat1, tHat2);
maxError = ComputeMaxError(d, first, last,
bezCurve, uPrime, &splitPoint);
if (maxError < error) {
DrawBezierCurve(3, bezCurve);
free((void *)u);
free((void *)bezCurve);
return;
}
free((void *)u);
u = uPrime;
}
}
/* Fitting failed -- split at max error point and fit recursively */
free((void *)u);
free((void *)bezCurve);
tHatCenter = ComputeCenterTangent(d, splitPoint);
FitCubic(d, first, splitPoint, tHat1, tHatCenter, error);
V2Negate(&tHatCenter);
FitCubic(d, splitPoint, last, tHatCenter, tHat2, error);
/* Parameterize points, and attempt to fit curve */
u = ChordLengthParameterize(d, first, last);
bezCurve = GenerateBezier(d, first, last, u, tHat1, tHat2);
/* Find max deviation of points to fitted curve */
maxError = ComputeMaxError(d, first, last, bezCurve, u, &splitPoint);
if (maxError < error) {
DrawBezierCurve(3, bezCurve);
free((void*)u);
free((void*)bezCurve);
return;
}
/* If error not too large, try some reparameterization and iteration */
if (maxError < iterationError) {
for (i = 0; i < maxIterations; i++) {
uPrime = Reparameterize(d, first, last, u, bezCurve);
bezCurve = GenerateBezier(d, first, last, uPrime, tHat1, tHat2);
maxError = ComputeMaxError(d, first, last,
bezCurve, uPrime, &splitPoint);
if (maxError < error) {
DrawBezierCurve(3, bezCurve);
free((void*)u);
free((void*)bezCurve);
return;
}
free((void*)u);
u = uPrime;
}
}
/* Fitting failed -- split at max error point and fit recursively */
free((void*)u);
free((void*)bezCurve);
tHatCenter = ComputeCenterTangent(d, splitPoint);
FitCubic(d, first, splitPoint, tHat1, tHatCenter, error);
V2Negate(&tHatCenter);
FitCubic(d, splitPoint, last, tHatCenter, tHat2, error);
}

182
source/blender/freestyle/intern/geometry/FitCurve.h
View File

@ -1,101 +1,125 @@
//
// Filename : FitCurve.h
// Author(s) : Stephane Grabli
// Purpose : An Algorithm for Automatically Fitting Digitized Curves
// by Philip J. Schneider
// from "Graphics Gems", Academic Press, 1990
// Date of creation : 06/06/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 __FITCURVE_H__
#define __FITCURVE_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 FITCURVE_H
# define FITCURVE_H
/** \file blender/freestyle/intern/geometry/FitCurve.h
* \ingroup freestyle
* \brief An Algorithm for Automatically Fitting Digitized Curves by Philip J. Schneider,
* \brief from "Graphics Gems", Academic Press, 1990
* \author Stephane Grabli
* \date 06/06/2003
*/
#include <vector>
#include "../system/FreestyleConfig.h"
#include "Geom.h"
#include "../system/FreestyleConfig.h"
using namespace Geometry;
typedef struct Point2Struct { /* 2d point */
/* 2d point */
typedef struct Point2Struct
{
double coordinates[2];
Point2Struct() {coordinates[0]=0;coordinates[1]=0;}
inline double operator[](const int i) const
{
return coordinates[i];
}
inline double& operator[](const int i)
{
return coordinates[i];
}
inline double x() const {return coordinates[0];}
inline double y() const {return coordinates[1];}
} Point2;
Point2Struct()
{
coordinates[0] = 0;
coordinates[1] = 0;
}
inline double operator[](const int i) const
{
return coordinates[i];
}
inline double& operator[](const int i)
{
return coordinates[i];
}
inline double x() const
{
return coordinates[0];
}
inline double y() const
{
return coordinates[1];
}
} Point2;
typedef Point2 Vector2;
class LIB_GEOMETRY_EXPORT FitCurveWrapper
{
private:
std::vector<Vector2> _vertices;
std::vector<Vector2> _vertices;
public:
FitCurveWrapper();
~FitCurveWrapper();
FitCurveWrapper();
~FitCurveWrapper();
/*! Fits a set of 2D data points to a set of Bezier Curve segments
* data
* Input data points
* oCurve
* Control points of the sets of bezier curve segments.
* Each segment is made of 4 points (polynomial degree of curve = 3)
* error
* max error tolerance between resulting curve and input data
*/
void FitCurve(std::vector<Vec2d>& data, std::vector<Vec2d>& oCurve, double error);
/*! Fits a set of 2D data points to a set of Bezier Curve segments
* data
* Input data points
* oCurve
* Control points of the sets of bezier curve segments.
* Each segment is made of 4 points (polynomial degree of curve = 3)
* error
* max error tolerance between resulting curve and input data
*/
void FitCurve(std::vector<Vec2d>& data, std::vector<Vec2d>& oCurve, double error);
protected:
/* Vec2d *d; Array of digitized points */
/* int nPts; Number of digitized points */
/* double error; User-defined error squared */
void FitCurve(Vector2 *d, int nPts, double error);
/*! Draws a Bezier curve segment
* n
* degree of curve (=3)
* curve
* bezier segments control points
*/
void DrawBezierCurve(int n, Vector2 *curve);
/* Vec2d *d; Array of digitized points */
/* int first, last; Indices of first and last pts in region */
/* Vec2d tHat1, tHat2; Unit tangent vectors at endpoints */
/* double error; User-defined error squared */
void FitCubic(Vector2 *d, int first, int last, Vector2 tHat1, Vector2 tHat2, double error);
/* Vec2d *d; Array of digitized points
* int nPts; Number of digitized points
* double error; User-defined error squared
*/
void FitCurve(Vector2 *d, int nPts, double error);
/*! Draws a Bezier curve segment
* n
* degree of curve (=3)
* curve
* bezier segments control points
*/
void DrawBezierCurve(int n, Vector2 *curve);
/* Vec2d *d; Array of digitized points
* int first, last; Indices of first and last pts in region
* Vec2d tHat1, tHat2; Unit tangent vectors at endpoints
* double error; User-defined error squared
*/
void FitCubic(Vector2 *d, int first, int last, Vector2 tHat1, Vector2 tHat2, double error);
};
#endif // FITCURVE_H
#endif // __FITCURVE_H__

132
source/blender/freestyle/intern/geometry/Geom.h
View File

@ -1,78 +1,84 @@
//
// Filename : Geom.h
// Author(s) : Sylvain Paris
// Emmanuel Turquin
// Stephane Grabli
// Purpose : Vectors and Matrices (useful type definitions)
// Date of creation : 20/05/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 __GEOM_H__
#define __GEOM_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/geometry/Geom.h
* \ingroup freestyle
* \brief Vectors and Matrices (useful type definitions)
* \author Sylvain Paris
* \author Emmanuel Turquin
* \author Stephane Grabli
* \date 20/05/2003
*/
#ifndef GEOM_H
# define GEOM_H
#include "VecMat.h"
# include "VecMat.h"
# include "../system/Precision.h"
#include "../system/Precision.h"
namespace Geometry {
typedef VecMat::Vec2<unsigned> Vec2u;
typedef VecMat::Vec2<int> Vec2i;
typedef VecMat::Vec2<float> Vec2f;
typedef VecMat::Vec2<double> Vec2d;
typedef VecMat::Vec2<real> Vec2r;
typedef VecMat::Vec2<unsigned> Vec2u;
typedef VecMat::Vec2<int> Vec2i;
typedef VecMat::Vec2<float> Vec2f;
typedef VecMat::Vec2<double> Vec2d;
typedef VecMat::Vec2<real> Vec2r;
typedef VecMat::Vec3<unsigned> Vec3u;
typedef VecMat::Vec3<int> Vec3i;
typedef VecMat::Vec3<float> Vec3f;
typedef VecMat::Vec3<double> Vec3d;
typedef VecMat::Vec3<real> Vec3r;
typedef VecMat::Vec3<unsigned> Vec3u;
typedef VecMat::Vec3<int> Vec3i;
typedef VecMat::Vec3<float> Vec3f;
typedef VecMat::Vec3<double> Vec3d;
typedef VecMat::Vec3<real> Vec3r;
typedef VecMat::HVec3<unsigned> HVec3u;
typedef VecMat::HVec3<int> HVec3i;
typedef VecMat::HVec3<float> HVec3f;
typedef VecMat::HVec3<double> HVec3d;
typedef VecMat::HVec3<real> HVec3r;
typedef VecMat::HVec3<unsigned> HVec3u;
typedef VecMat::HVec3<int> HVec3i;
typedef VecMat::HVec3<float> HVec3f;
typedef VecMat::HVec3<double> HVec3d;
typedef VecMat::HVec3<real> HVec3r;
typedef VecMat::SquareMatrix<unsigned, 2> Matrix22u;
typedef VecMat::SquareMatrix<int, 2> Matrix22i;
typedef VecMat::SquareMatrix<float, 2> Matrix22f;
typedef VecMat::SquareMatrix<double, 2> Matrix22d;
typedef VecMat::SquareMatrix<real, 2> Matrix22r;
typedef VecMat::SquareMatrix<unsigned, 2> Matrix22u;
typedef VecMat::SquareMatrix<int, 2> Matrix22i;
typedef VecMat::SquareMatrix<float, 2> Matrix22f;
typedef VecMat::SquareMatrix<double, 2> Matrix22d;
typedef VecMat::SquareMatrix<real, 2> Matrix22r;
typedef VecMat::SquareMatrix<unsigned, 3> Matrix33u;
typedef VecMat::SquareMatrix<int, 3> Matrix33i;
typedef VecMat::SquareMatrix<float, 3> Matrix33f;
typedef VecMat::SquareMatrix<double, 3> Matrix33d;
typedef VecMat::SquareMatrix<real, 3> Matrix33r;
typedef VecMat::SquareMatrix<unsigned, 3> Matrix33u;
typedef VecMat::SquareMatrix<int, 3> Matrix33i;
typedef VecMat::SquareMatrix<float, 3> Matrix33f;
typedef VecMat::SquareMatrix<double, 3> Matrix33d;
typedef VecMat::SquareMatrix<real, 3> Matrix33r;
typedef VecMat::SquareMatrix<unsigned, 4> Matrix44u;
typedef VecMat::SquareMatrix<int, 4> Matrix44i;
typedef VecMat::SquareMatrix<float, 4> Matrix44f;
typedef VecMat::SquareMatrix<double, 4> Matrix44d;
typedef VecMat::SquareMatrix<real, 4> Matrix44r;
typedef VecMat::SquareMatrix<unsigned, 4> Matrix44u;
typedef VecMat::SquareMatrix<int, 4> Matrix44i;
typedef VecMat::SquareMatrix<float, 4> Matrix44f;
typedef VecMat::SquareMatrix<double, 4> Matrix44d;
typedef VecMat::SquareMatrix<real, 4> Matrix44r;
} // end of namespace Geometry
#endif // GEOM_H
#endif // __GEOM_H__

385
source/blender/freestyle/intern/geometry/GeomCleaner.cpp
View File

@ -1,240 +1,233 @@
/*
* ***** 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/geometry/GeomCleaner.cpp
* \ingroup freestyle
* \brief Class to define a cleaner of geometry providing a set of useful tools
* \author Stephane Grabli
* \date 04/03/2002
*/
//#if defined(__GNUC__) && (__GNUC__ >= 3)
//// hash_map is not part of the C++ standard anymore;
//// hash_map.h has been kept though for backward compatibility
//# include <hash_map.h>
//#else
//# include <hash_map>
//#endif
#if 0
#if defined(__GNUC__) && (__GNUC__ >= 3)
// hash_map is not part of the C++ standard anymore;
// hash_map.h has been kept though for backward compatibility
# include <hash_map.h>
#else
# include <hash_map>
#endif
#endif
#include <stdio.h>
#include <list>
#include <map>
#include "../system/TimeUtils.h"
#include "GeomCleaner.h"
#include "../system/TimeUtils.h"
using namespace std;
void GeomCleaner::SortIndexedVertexArray( const float *iVertices, unsigned iVSize,
const unsigned *iIndices, unsigned iISize,
real **oVertices,
unsigned **oIndices)
void GeomCleaner::SortIndexedVertexArray(const float *iVertices, unsigned iVSize, const unsigned *iIndices,
unsigned iISize, real **oVertices, unsigned **oIndices)
{
// First, we build a list of IndexVertex:
list<IndexedVertex> indexedVertices;
unsigned i;
for(i=0; i<iVSize; i+= 3)
{
indexedVertices.push_back(IndexedVertex(Vec3r(iVertices[i], iVertices[i+1], iVertices[i+2]), i/3));
}
// First, we build a list of IndexVertex:
list<IndexedVertex> indexedVertices;
unsigned i;
for (i = 0; i < iVSize; i += 3) {
indexedVertices.push_back(IndexedVertex(Vec3r(iVertices[i], iVertices[i + 1], iVertices[i + 2]), i / 3));
}
// q-sort
indexedVertices.sort();
// q-sort
indexedVertices.sort();
// build the indices mapping array:
unsigned *mapIndices = new unsigned[iVSize/3];
*oVertices = new real[iVSize];
list<IndexedVertex>::iterator iv;
unsigned newIndex = 0;
unsigned vIndex = 0;
for(iv=indexedVertices.begin(); iv!=indexedVertices.end(); iv++)
{
// Build the final results:
(*oVertices)[vIndex] = iv->x();
(*oVertices)[vIndex+1] = iv->y();
(*oVertices)[vIndex+2] = iv->z();
// build the indices mapping array:
unsigned *mapIndices = new unsigned[iVSize / 3];
*oVertices = new real[iVSize];
list<IndexedVertex>::iterator iv;
unsigned newIndex = 0;
unsigned vIndex = 0;
for (iv = indexedVertices.begin(); iv != indexedVertices.end(); iv++) {
// Build the final results:
(*oVertices)[vIndex] = iv->x();
(*oVertices)[vIndex + 1] = iv->y();
(*oVertices)[vIndex + 2] = iv->z();
mapIndices[iv->index()] = newIndex;
newIndex++;
vIndex+=3;
}
mapIndices[iv->index()] = newIndex;
newIndex++;
vIndex += 3;
}
// Build the final index array:
*oIndices = new unsigned[iISize];
for(i=0; i<iISize; i++)
{
(*oIndices)[i] = 3*mapIndices[iIndices[i]/3];
}
// Build the final index array:
*oIndices = new unsigned[iISize];
for (i = 0; i < iISize; i++) {
(*oIndices)[i] = 3 * mapIndices[iIndices[i] / 3];
}
delete [] mapIndices;
delete [] mapIndices;
}
void GeomCleaner::CompressIndexedVertexArray(const real *iVertices, unsigned iVSize,
const unsigned *iIndices, unsigned iISize,
real **oVertices, unsigned *oVSize,
unsigned **oIndices)
void GeomCleaner::CompressIndexedVertexArray(const real *iVertices, unsigned iVSize, const unsigned *iIndices,
unsigned iISize, real **oVertices, unsigned *oVSize, unsigned **oIndices)
{
// First, we build a list of IndexVertex:
vector<Vec3r> vertices;
unsigned i;
for(i=0; i<iVSize; i+= 3)
{
vertices.push_back(Vec3r(iVertices[i], iVertices[i+1], iVertices[i+2]));
}
// First, we build a list of IndexVertex:
vector<Vec3r> vertices;
unsigned i;
for (i = 0; i < iVSize; i += 3) {
vertices.push_back(Vec3r(iVertices[i], iVertices[i + 1], iVertices[i + 2]));
}
unsigned *mapVertex = new unsigned[iVSize];
vector<Vec3r>::iterator v = vertices.begin();
vector<Vec3r> compressedVertices;
Vec3r previous = *v;
mapVertex[0] = 0;
compressedVertices.push_back(vertices.front());
unsigned *mapVertex = new unsigned[iVSize];
vector<Vec3r>::iterator v = vertices.begin();
v++;
Vec3r current;
i=1;
for(; v!=vertices.end(); v++)
{
current = *v;
if(current == previous)
mapVertex[i] = compressedVertices.size()-1;
else
{
compressedVertices.push_back(current);
mapVertex[i] = compressedVertices.size()-1;
}
previous = current;
i++;
}
vector<Vec3r> compressedVertices;
Vec3r previous = *v;
mapVertex[0] = 0;
compressedVertices.push_back(vertices.front());
// Builds the resulting vertex array:
*oVSize = 3*compressedVertices.size();
*oVertices = new real [*oVSize];
i=0;
for(v=compressedVertices.begin(); v!=compressedVertices.end(); v++)
{
(*oVertices)[i] = (*v)[0];
(*oVertices)[i+1] = (*v)[1];
(*oVertices)[i+2] = (*v)[2];
i += 3;
}
v++;
Vec3r current;
i = 1;
for (; v != vertices.end(); v++) {
current = *v;
if (current == previous)
mapVertex[i] = compressedVertices.size() - 1;
else {
compressedVertices.push_back(current);
mapVertex[i] = compressedVertices.size() - 1;
}
previous = current;
i++;
}
// Map the index array:
*oIndices = new unsigned[iISize];
for(i=0; i<iISize; i++)
{
(*oIndices)[i] = 3*mapVertex[iIndices[i]/3];
}
// Builds the resulting vertex array:
*oVSize = 3 * compressedVertices.size();
*oVertices = new real[*oVSize];
i = 0;
for (v = compressedVertices.begin(); v != compressedVertices.end(); v++) {
(*oVertices)[i] = (*v)[0];
(*oVertices)[i + 1] = (*v)[1];
(*oVertices)[i + 2] = (*v)[2];
i += 3;
}
delete [] mapVertex;
// Map the index array:
*oIndices = new unsigned[iISize];
for (i = 0; i < iISize; i++) {
(*oIndices)[i] = 3 * mapVertex[iIndices[i] / 3];
}
delete [] mapVertex;
}
void GeomCleaner::SortAndCompressIndexedVertexArray(const float *iVertices, unsigned iVSize,
const unsigned *iIndices, unsigned iISize,
real **oVertices, unsigned *oVSize,
void GeomCleaner::SortAndCompressIndexedVertexArray(const float *iVertices, unsigned iVSize, const unsigned *iIndices,
unsigned iISize, real **oVertices, unsigned *oVSize,
unsigned **oIndices)
{
// tmp arrays used to store the sorted data:
real *tmpVertices;
unsigned *tmpIndices;
// tmp arrays used to store the sorted data:
real *tmpVertices;
unsigned *tmpIndices;
Chronometer chrono;
// Sort data
chrono.start();
GeomCleaner::SortIndexedVertexArray(iVertices, iVSize, iIndices, iISize, &tmpVertices, &tmpIndices);
printf("Sorting: %lf\n", chrono.stop());
Chronometer chrono;
// Sort data
chrono.start();
GeomCleaner::SortIndexedVertexArray(iVertices, iVSize,
iIndices, iISize,
&tmpVertices, &tmpIndices
);
printf("Sorting: %lf\n", chrono.stop());
// compress data
chrono.start();
GeomCleaner::CompressIndexedVertexArray(tmpVertices, iVSize, tmpIndices, iISize, oVertices, oVSize, oIndices);
printf("Merging: %lf\n", chrono.stop());
// compress data
chrono.start();
GeomCleaner::CompressIndexedVertexArray(tmpVertices, iVSize,
tmpIndices, iISize,
oVertices, oVSize,
oIndices);
printf("Merging: %lf\n", chrono.stop());
// deallocates memory:
delete [] tmpVertices;
delete [] tmpIndices;
// deallocates memory:
delete [] tmpVertices;
delete [] tmpIndices;
}
/*! Defines a hash table used for searching the Cells */
struct GeomCleanerHasher{
#define _MUL 950706376UL
#define _MOD 2147483647UL
inline size_t operator() (const Vec3r& p) const {
size_t res = ((unsigned long) (p[0] * _MUL)) % _MOD;
res = ((res + (unsigned long) (p[1]) * _MUL)) % _MOD;
return ((res +(unsigned long) (p[2]) * _MUL)) % _MOD;
}
inline size_t operator() (const Vec3r& p) const
{
size_t res = ((unsigned long) (p[0] * _MUL)) % _MOD;
res = ((res + (unsigned long) (p[1]) * _MUL)) % _MOD;
return ((res +(unsigned long) (p[2]) * _MUL)) % _MOD;
}
#undef _MUL
#undef _MOD
};
void GeomCleaner::CleanIndexedVertexArray(const float *iVertices, unsigned iVSize,
const unsigned *iIndices, unsigned iISize,
real **oVertices, unsigned *oVSize,
unsigned **oIndices)
void GeomCleaner::CleanIndexedVertexArray(const float *iVertices, unsigned iVSize, const unsigned *iIndices,
unsigned iISize, real **oVertices, unsigned *oVSize, unsigned **oIndices)
{
typedef map<Vec3r, unsigned> cleanHashTable;
vector<Vec3r> vertices;
unsigned i;
for(i=0; i<iVSize; i+= 3)
vertices.push_back(Vec3r(iVertices[i], iVertices[i+1], iVertices[i+2]));
cleanHashTable ht;
vector<unsigned> newIndices;
vector<Vec3r> newVertices;
// elimination of needless points
unsigned currentIndex = 0;
vector<Vec3r>::const_iterator v = vertices.begin();
vector<Vec3r>::const_iterator end = vertices.end();
cleanHashTable::const_iterator found;
for(; v!=end; v++)
{
found = ht.find(*v);
if(found != ht.end())
{
// The vertex is already in the new array.
newIndices.push_back((*found).second);
}
else
{
newVertices.push_back(*v);
newIndices.push_back(currentIndex);
ht[*v] = currentIndex;
currentIndex++;
}
}
typedef map<Vec3r, unsigned> cleanHashTable;
vector<Vec3r> vertices;
unsigned i;
for (i = 0; i < iVSize; i += 3)
vertices.push_back(Vec3r(iVertices[i], iVertices[i + 1], iVertices[i + 2]));
// creation of oVertices array:
*oVSize = 3*newVertices.size();
*oVertices = new real[*oVSize];
currentIndex = 0;
end = newVertices.end();
for(v=newVertices.begin(); v!=end ; v++)
{
(*oVertices)[currentIndex++] = (*v)[0];
(*oVertices)[currentIndex++] = (*v)[1];
(*oVertices)[currentIndex++] = (*v)[2];
}
cleanHashTable ht;
vector<unsigned> newIndices;
vector<Vec3r> newVertices;
// map new indices:
*oIndices = new unsigned[iISize];
for(i=0; i<iISize; i++)
(*oIndices)[i] = 3*newIndices[iIndices[i]/3];
// elimination of needless points
unsigned currentIndex = 0;
vector<Vec3r>::const_iterator v = vertices.begin();
vector<Vec3r>::const_iterator end = vertices.end();
cleanHashTable::const_iterator found;
for (; v != end; v++) {
found = ht.find(*v);
if (found != ht.end()) {
// The vertex is already in the new array.
newIndices.push_back((*found).second);
}
else {
newVertices.push_back(*v);
newIndices.push_back(currentIndex);
ht[*v] = currentIndex;
currentIndex++;
}
}
// creation of oVertices array:
*oVSize = 3 * newVertices.size();
*oVertices = new real[*oVSize];
currentIndex = 0;
end = newVertices.end();
for (v = newVertices.begin(); v != end ; v++) {
(*oVertices)[currentIndex++] = (*v)[0];
(*oVertices)[currentIndex++] = (*v)[1];
(*oVertices)[currentIndex++] = (*v)[2];
}
// map new indices:
*oIndices = new unsigned[iISize];
for (i = 0; i < iISize; i++)
(*oIndices)[i] = 3 * newIndices[iIndices[i] / 3];
}

392
source/blender/freestyle/intern/geometry/GeomCleaner.h
View File

@ -1,219 +1,227 @@
//
// Filename : GeomCleaner.h
// Author : Stephane Grabli
// Purpose : Class to define a cleaner of geometry providing
// a set of useful tools
// Date of creation : 04/03/2002
//
///////////////////////////////////////////////////////////////////////////////
/*
* ***** 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 __GEOMCLEANER_H__
#define __GEOMCLEANER_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/geometry/GeomCleaner.h
* \ingroup freestyle
* \brief Class to define a cleaner of geometry providing a set of useful tools
* \author Stephane Grabli
* \date 04/03/2002
*/
#ifndef GEOMCLEANER_H
# define GEOMCLEANER_H
#include "Geom.h"
# include "../system/FreestyleConfig.h"
# include "Geom.h"
#include "../system/FreestyleConfig.h"
using namespace Geometry;
class LIB_GEOMETRY_EXPORT GeomCleaner
{
public:
inline GeomCleaner() {}
inline ~GeomCleaner() {}
inline GeomCleaner() {}
inline ~GeomCleaner() {}
/*! Sorts an array of Indexed vertices
* iVertices
* Array of vertices to sort. It is organized as a float series of vertex coordinates: XYZXYZXYZ...
* iVSize
* The size of iVertices array.
* iIndices
* The array containing the vertex indices (used to refer to the vertex coordinates in an indexed face). Each
* element is an unsignedeger multiple of 3.
* iISize
* The size of iIndices array
* oVertices
* Output of sorted vertices. A vertex v1 precedes another one v2 in this array if v1.x<v2.x,
* or v1.x=v2.x && v1.y < v2.y or v1.x=v2.y && v1.y=v2.y && v1.z < v2.z.
* The array is organized as a 3-float serie giving the vertices coordinates: XYZXYZXYZ...
* oIndices
* Output corresponding to the iIndices array but reorganized in order to match the sorted vertex array.
*/
static void SortIndexedVertexArray(const float *iVertices, unsigned iVSize, const unsigned *iIndices,
unsigned iISize, real **oVertices, unsigned **oIndices);
/*! Sorts an array of Indexed vertices
* iVertices
* Array of vertices to sort. It is organized as a
* float series of vertex coordinates: XYZXYZXYZ...
* iVSize
* The size of iVertices array.
* iIndices
* The array containing the vertex indices (used to refer
* to the vertex coordinates in an indexed face). Each
* element is an unsignedeger multiple of 3.
* iISize
* The size of iIndices array
* oVertices
* Output of sorted vertices. A vertex v1 precedes another one
* v2 in this array if v1.x<v2.x, or v1.x=v2.x && v1.y < v2.y
* or v1.x=v2.y && v1.y=v2.y && v1.z < v2.z.
* The array is organized as a 3-float serie giving
* the vertices coordinates: XYZXYZXYZ...
* oIndices
* Output corresponding to the iIndices array but
* reorganized in order to match the sorted vertex array.
*/
/*! Compress a SORTED indexed vertex array by eliminating multiple appearing occurences of a single vertex.
* iVertices
* The SORTED vertex array to compress. It is organized as a float series of vertex coordinates: XYZXYZXYZ...
* iVSize
* The size of iVertices array.
* iIndices
* The array containing the vertex indices (used to refer to the vertex coordinates in an indexed face).
* Each element is an unsignedeger multiple of 3.
* iISize
* The size of iIndices array
* oVertices
* The vertex array, result of the compression.
* The array is organized as a 3-float serie giving the vertices coordinates: XYZXYZXYZ...
* oVSize
* The size of oVertices.
* oIndices
* The indices array, reorganized to match the compressed oVertices array.
*/
static void CompressIndexedVertexArray(const real *iVertices, unsigned iVSize, const unsigned *iIndices,
unsigned iISize, real **oVertices, unsigned *oVSize, unsigned **oIndices);
static void SortIndexedVertexArray(const float *iVertices, unsigned iVSize,
const unsigned *iIndices, unsigned iISize,
real **oVertices,
unsigned **oIndices);
/*! Sorts and compress an array of indexed vertices.
* iVertices
* The vertex array to sort then compress. It is organized as a float series of
* vertex coordinates: XYZXYZXYZ...
* iVSize
* The size of iVertices array.
* iIndices
* The array containing the vertex indices (used to refer to the vertex coordinates in an indexed face).
* Each element is an unsignedeger multiple of 3.
* iISize
* The size of iIndices array
* oVertices
* The vertex array, result of the sorting-compression.
* The array is organized as a 3-float serie giving the vertices coordinates: XYZXYZXYZ...
* oVSize
* The size of oVertices.
* oIndices
* The indices array, reorganized to match the sorted and compressed oVertices array.
*/
static void SortAndCompressIndexedVertexArray(const float *iVertices, unsigned iVSize, const unsigned *iIndices,
unsigned iISize, real **oVertices, unsigned *oVSize,
unsigned **oIndices);
/*! Compress a SORTED indexed vertex array by eliminating
* multiple appearing occurences of a single vertex.
* iVertices
* The SORTED vertex array to compress. It is organized as a
* float series of vertex coordinates: XYZXYZXYZ...
* iVSize
* The size of iVertices array.
* iIndices
* The array containing the vertex indices (used to refer
* to the vertex coordinates in an indexed face). Each
* element is an unsignedeger multiple of 3.
* iISize
* The size of iIndices array
* oVertices
* The vertex array, result of the compression.
* The array is organized as a 3-float serie giving
* the vertices coordinates: XYZXYZXYZ...
* oVSize
* The size of oVertices.
* oIndices
* The indices array, reorganized to match the compressed
* oVertices array.
*/
static void CompressIndexedVertexArray(const real *iVertices, unsigned iVSize,
const unsigned *iIndices, unsigned iISize,
real **oVertices, unsigned *oVSize,
unsigned **oIndices);
/*! Sorts and compress an array of indexed vertices.
* iVertices
* The vertex array to sort then compress. It is organized as a
* float series of vertex coordinates: XYZXYZXYZ...
* iVSize
* The size of iVertices array.
* iIndices
* The array containing the vertex indices (used to refer
* to the vertex coordinates in an indexed face). Each
* element is an unsignedeger multiple of 3.
* iISize
* The size of iIndices array
* oVertices
* The vertex array, result of the sorting-compression.
* The array is organized as a 3-float serie giving
* the vertices coordinates: XYZXYZXYZ...
* oVSize
* The size of oVertices.
* oIndices
* The indices array, reorganized to match the sorted and compressed
* oVertices array.
*/
static void SortAndCompressIndexedVertexArray(const float *iVertices, unsigned iVSize,
const unsigned *iIndices, unsigned iISize,
real **oVertices, unsigned *oVSize,
unsigned **oIndices);
/*! Cleans an indexed vertex array. (Identical to
* SortAndCompress except that we use here a hash
* table to create the new array.)
* iVertices
* The vertex array to sort then compress. It is organized as a
* float series of vertex coordinates: XYZXYZXYZ...
* iVSize
* The size of iVertices array.
* iIndices
* The array containing the vertex indices (used to refer
* to the vertex coordinates in an indexed face). Each
* element is an unsignedeger multiple of 3.
* iISize
* The size of iIndices array
* oVertices
* The vertex array, result of the sorting-compression.
* The array is organized as a 3-float serie giving
* the vertices coordinates: XYZXYZXYZ...
* oVSize
* The size of oVertices.
* oIndices
* The indices array, reorganized to match the sorted and compressed
* oVertices array.
*/
static void CleanIndexedVertexArray(const float *iVertices, unsigned iVSize,
const unsigned *iIndices, unsigned iISize,
real **oVertices, unsigned *oVSize,
unsigned **oIndices);
/*! Cleans an indexed vertex array. (Identical to SortAndCompress except that we use here a hash table
* to create the new array.)
* iVertices
* The vertex array to sort then compress. It is organized as a float series of
* vertex coordinates: XYZXYZXYZ...
* iVSize
* The size of iVertices array.
* iIndices
* The array containing the vertex indices (used to refer to the vertex coordinates in an indexed face).
* Each element is an unsignedeger multiple of 3.
* iISize
* The size of iIndices array
* oVertices
* The vertex array, result of the sorting-compression.
* The array is organized as a 3-float serie giving the vertices coordinates: XYZXYZXYZ...
* oVSize
* The size of oVertices.
* oIndices
* The indices array, reorganized to match the sorted and compressed oVertices array.
*/
static void CleanIndexedVertexArray(const float *iVertices, unsigned iVSize, const unsigned *iIndices,
unsigned iISize, real **oVertices, unsigned *oVSize, unsigned **oIndices);
};
/*! Binary operators */
//inline bool operator<(const IndexedVertex& iv1, const IndexedVertex& iv2);
/*! Class Indexed Vertex. Used to represent
* an indexed vertex by storing the vertex
* coordinates as well as its index
*/
/*! Class Indexed Vertex. Used to represent an indexed vertex by storing the vertex coordinates as well as its index */
class IndexedVertex
{
public:
private:
Vec3r _Vector;
unsigned _index;
public:
inline IndexedVertex() {}
inline IndexedVertex(Vec3r iVector, unsigned iIndex)
{
_Vector = iVector;
_index = iIndex;
}
/*! accessors */
inline const Vec3r& vector() const {return _Vector;}
inline unsigned index() {return _index;}
inline real x() {return _Vector[0];}
inline real y() {return _Vector[1];}
inline real z() {return _Vector[2];}
/*! modifiers */
inline void setVector(const Vec3r& iVector) {_Vector = iVector;}
inline void setIndex(unsigned iIndex) {_index = iIndex;}
Vec3r _Vector;
unsigned _index;
/*! operators */
IndexedVertex& operator=(const IndexedVertex& iv)
{
_Vector = iv._Vector;
_index = iv._index;
return *this;
}
inline real operator[](const unsigned i) {return _Vector[i];}
//friend inline bool operator<(const IndexedVertex& iv1, const IndexedVertex& iv2);
inline bool operator<(const IndexedVertex& v) const
{
return (_Vector < v._Vector);
}
inline bool operator==(const IndexedVertex& v)
{
return (_Vector == v._Vector);
}
public:
inline IndexedVertex() {}
inline IndexedVertex(Vec3r iVector, unsigned iIndex)
{
_Vector = iVector;
_index = iIndex;
}
/*! accessors */
inline const Vec3r& vector() const
{
return _Vector;
}
inline unsigned index()
{
return _index;
}
inline real x()
{
return _Vector[0];
}
inline real y()
{
return _Vector[1];
}
inline real z()
{
return _Vector[2];
}
/*! modifiers */
inline void setVector(const Vec3r& iVector)
{
_Vector = iVector;
}
inline void setIndex(unsigned iIndex)
{
_index = iIndex;
}
/*! operators */
IndexedVertex& operator=(const IndexedVertex& iv)
{
_Vector = iv._Vector;
_index = iv._index;
return *this;
}
inline real operator[](const unsigned i)
{
return _Vector[i];
}
//friend inline bool operator<(const IndexedVertex& iv1, const IndexedVertex& iv2);
inline bool operator<(const IndexedVertex& v) const
{
return (_Vector < v._Vector);
}
inline bool operator==(const IndexedVertex& v)
{
return (_Vector == v._Vector);
}
};
//bool operator<(const IndexedVertex& iv1, const IndexedVertex& iv2)
//{
// return iv1.operator<(iv2);
//}
#if 0
bool operator<(const IndexedVertex& iv1, const IndexedVertex& iv2)
{
return iv1.operator<(iv2);
}
#endif
#endif // GEOMCLEANER_H
#endif // __GEOMCLEANER_H__

1366
source/blender/freestyle/intern/geometry/GeomUtils.cpp
View File

File diff suppressed because it is too large Load Diff

513
source/blender/freestyle/intern/geometry/GeomUtils.h
View File

@ -1,310 +1,277 @@
//
// Filename : GeomUtils.h
// Author(s) : Stephane Grabli
// Purpose : Various tools for geometry
// Date of creation : 12/04/2002
//
///////////////////////////////////////////////////////////////////////////////
/*
* ***** 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 __GEOMUTILS_H__
#define __GEOMUTILS_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/geometry/GeomUtils.h
* \ingroup freestyle
* \brief Various tools for geometry
* \author Stephane Grabli
* \date 12/04/2002
*/
#ifndef GEOMUTILS_H
# define GEOMUTILS_H
#include <vector>
# include <vector>
# include "../system/FreestyleConfig.h"
# include "Geom.h"
#include "Geom.h"
#include "../system/FreestyleConfig.h"
using namespace std;
using namespace Geometry;
namespace GeomUtils {
//
// Templated procedures
//
/////////////////////////////////////////////////////////////////////////////
//
// Templated procedures
//
/////////////////////////////////////////////////////////////////////////////
/*! Computes the distance from a point P to a segment AB */
template<class T>
real distPointSegment( const T& P, const T& A , const T& B) {
T AB, AP, BP;
AB = B - A;
AP = P - A;
BP = P - B;
/*! Computes the distance from a point P to a segment AB */
template<class T>
real distPointSegment( const T& P, const T& A , const T& B)
{
T AB, AP, BP;
AB = B - A;
AP = P - A;
BP = P - B;
real c1(AB * AP);
if (c1 <= 0)
return AP.norm();
real c1(AB * AP);
if (c1 <= 0)
return AP.norm();
real c2(AB * AB);
if (c2 <= c1)
return BP.norm();
real c2(AB * AB);
if (c2 <= c1)
return BP.norm();
real b = c1 / c2;
T Pb, PPb;
Pb = A + b * AB;
PPb = P - Pb;
real b = c1 / c2;
T Pb, PPb;
Pb = A + b * AB;
PPb = P - Pb;
return PPb.norm();
}
return PPb.norm();
}
//
// Non-templated procedures
//
/////////////////////////////////////////////////////////////////////////////
//
// Non-templated procedures
//
/////////////////////////////////////////////////////////////////////////////
typedef enum {
DONT_INTERSECT,
DO_INTERSECT,
COLINEAR,
COINCIDENT,
} intersection_test;
typedef enum {
DONT_INTERSECT,
DO_INTERSECT,
COLINEAR,
COINCIDENT
} intersection_test;
LIB_GEOMETRY_EXPORT
intersection_test intersect2dSeg2dSeg(const Vec2r& p1, const Vec2r& p2, // first segment
const Vec2r& p3, const Vec2r& p4, // second segment
Vec2r& res); // found intersection point
LIB_GEOMETRY_EXPORT
intersection_test intersect2dSeg2dSeg(const Vec2r& p1, const Vec2r& p2, // first segment
const Vec2r& p3, const Vec2r& p4, // second segment
Vec2r& res); // found intersection point
LIB_GEOMETRY_EXPORT
intersection_test intersect2dLine2dLine(const Vec2r& p1, const Vec2r& p2, // first segment
const Vec2r& p3, const Vec2r& p4, // second segment
Vec2r& res); // found intersection point
LIB_GEOMETRY_EXPORT
intersection_test intersect2dLine2dLine(const Vec2r& p1, const Vec2r& p2, // first segment
const Vec2r& p3, const Vec2r& p4, // second segment
Vec2r& res); // found intersection point
LIB_GEOMETRY_EXPORT
intersection_test intersect2dSeg2dSegParametric(const Vec2r& p1, const Vec2r& p2, // first segment
const Vec2r& p3, const Vec2r& p4, // second segment
real& t, // I = P1 + t * P1P2)
real& u, // I = P3 + u * P3P4
real epsilon = M_EPSILON);
LIB_GEOMETRY_EXPORT
intersection_test intersect2dSeg2dSegParametric(const Vec2r& p1, const Vec2r& p2, // first segment
const Vec2r& p3, const Vec2r& p4, // second segment
real& t, // I = P1 + t * P1P2)
real& u, // I = P3 + u * P3P4
real epsilon = M_EPSILON);
/*! check whether a 2D segment intersect a 2D region or not */
LIB_GEOMETRY_EXPORT
bool intersect2dSeg2dArea(const Vec2r& min, const Vec2r& max, const Vec2r& A, const Vec2r& B);
/*! check whether a 2D segment intersect a 2D region or not */
LIB_GEOMETRY_EXPORT
bool intersect2dSeg2dArea(const Vec2r& min,
const Vec2r& max,
const Vec2r& A,
const Vec2r& B);
/*! check whether a 2D segment is included in a 2D region or not */
LIB_GEOMETRY_EXPORT
bool include2dSeg2dArea(const Vec2r& min,
const Vec2r& max,
const Vec2r& A,
const Vec2r& B);
/*! check whether a 2D segment is included in a 2D region or not */
LIB_GEOMETRY_EXPORT
bool include2dSeg2dArea(const Vec2r& min, const Vec2r& max, const Vec2r& A, const Vec2r& B);
/*! Box-triangle overlap test, adapted from Tomas Akenine-Möller code */
LIB_GEOMETRY_EXPORT
bool overlapTriangleBox(Vec3r& boxcenter,
Vec3r& boxhalfsize,
Vec3r triverts[3]);
/*! Box-triangle overlap test, adapted from Tomas Akenine-Möller code */
LIB_GEOMETRY_EXPORT
bool overlapTriangleBox(Vec3r& boxcenter, Vec3r& boxhalfsize, Vec3r triverts[3]);
/*! Fast, Minimum Storage Ray-Triangle Intersection,
* adapted from Tomas Möller and Ben Trumbore code.
*/
LIB_GEOMETRY_EXPORT
bool intersectRayTriangle(const Vec3r& orig, const Vec3r& dir,
const Vec3r& v0, const Vec3r& v1, const Vec3r& v2,
real& t, // I = orig + t * dir
real& u, real& v, // I = (1-u-v)*v0+u*v1+v*v2
const real epsilon = M_EPSILON); // the epsilon to use
/*! Fast, Minimum Storage Ray-Triangle Intersection, adapted from Tomas Möller and Ben Trumbore code. */
LIB_GEOMETRY_EXPORT
bool intersectRayTriangle(const Vec3r& orig, const Vec3r& dir, const Vec3r& v0, const Vec3r& v1, const Vec3r& v2,
real& t, // I = orig + t * dir
real& u, real& v, // I = (1 - u - v) * v0 + u * v1 + v * v2
const real epsilon = M_EPSILON); // the epsilon to use
/*! Intersection between plane and ray
* adapted from Graphics Gems, Didier Badouel
*/
LIB_GEOMETRY_EXPORT
intersection_test intersectRayPlane(const Vec3r& orig, const Vec3r& dir, // ray origin and direction
const Vec3r& norm, const real d, // plane's normal and offset (plane = { P / P.N + d = 0 })
real& t, // I = orig + t * dir
const real epsilon = M_EPSILON); // the epsilon to use
/*! Intersection between plane and ray adapted from Graphics Gems, Didier Badouel */
LIB_GEOMETRY_EXPORT
intersection_test intersectRayPlane(const Vec3r& orig, const Vec3r& dir, // ray origin and direction
// plane's normal and offset (plane = { P / P.N + d = 0 })
const Vec3r& norm, const real d,
real& t, // I = orig + t * dir
const real epsilon = M_EPSILON); // the epsilon to use
/*! Intersection Ray-Bounding box (axis aligned).
* Adapted from Williams et al, "An Efficient Robust Ray-Box Intersection Algorithm",
* JGT 10:1 (2005), pp. 49-54.
* Returns
*/
LIB_GEOMETRY_EXPORT
bool intersectRayBBox(const Vec3r& orig, const Vec3r& dir, // ray origin and direction
const Vec3r& boxMin, const Vec3r& boxMax, // the bbox
real t0, real t1, // the interval in which at least on of the intersections must happen
real& tmin, real& tmax, // Imin=orig+tmin*dir is the first intersection, Imax=orig+tmax*dir is the second intersection
real epsilon = M_EPSILON); // the epsilon to use
/*! Intersection Ray-Bounding box (axis aligned).
* Adapted from Williams et al, "An Efficient Robust Ray-Box Intersection Algorithm", JGT 10:1 (2005), pp. 49-54.
*/
LIB_GEOMETRY_EXPORT
bool intersectRayBBox(const Vec3r& orig, const Vec3r& dir, // ray origin and direction
const Vec3r& boxMin, const Vec3r& boxMax, // the bbox
// the interval in which at least on of the intersections must happen
real t0, real t1,
real& tmin, // Imin = orig + tmin * dir is the first intersection
real& tmax, // Imax = orig + tmax * dir is the second intersection
real epsilon = M_EPSILON); // the epsilon to use
/*! Checks whether 3D point P lies inside or outside of the triangle ABC */
LIB_GEOMETRY_EXPORT
bool includePointTriangle(const Vec3r& P, const Vec3r& A, const Vec3r& B, const Vec3r& C);
/*! Checks whether 3D point P lies inside or outside of the triangle ABC */
LIB_GEOMETRY_EXPORT
bool includePointTriangle(const Vec3r& P,
const Vec3r& A,
const Vec3r& B,
const Vec3r& C);
LIB_GEOMETRY_EXPORT
void transformVertex(const Vec3r& vert, const Matrix44r& matrix, Vec3r& res);
LIB_GEOMETRY_EXPORT
void transformVertex(const Vec3r& vert,
const Matrix44r& matrix,
Vec3r& res);
LIB_GEOMETRY_EXPORT
void transformVertices(const vector<Vec3r>& vertices,
const Matrix44r& trans,
vector<Vec3r>& res);
LIB_GEOMETRY_EXPORT
void transformVertices(const vector<Vec3r>& vertices, const Matrix44r& trans, vector<Vec3r>& res);
LIB_GEOMETRY_EXPORT
Vec3r rotateVector(const Matrix44r& mat, const Vec3r& v);
LIB_GEOMETRY_EXPORT
Vec3r rotateVector(const Matrix44r& mat, const Vec3r& v);
//
// Coordinates systems changing procedures
//
/////////////////////////////////////////////////////////////////////////////
//
// Coordinates systems changing procedures
//
/////////////////////////////////////////////////////////////////////////////
/*! From world to image
* p
* point's coordinates expressed in world coordinates system
* q
* vector in which the result will be stored
* model_view_matrix
* The model view matrix expressed in line major order (OpenGL
* matrices are column major ordered)
* projection_matrix
* The projection matrix expressed in line major order (OpenGL
* matrices are column major ordered)
* viewport
* The viewport: x,y coordinates followed by width and height (OpenGL like viewport)
*/
LIB_GEOMETRY_EXPORT
void fromWorldToImage(const Vec3r& p,
Vec3r& q,
const real model_view_matrix[4][4],
const real projection_matrix[4][4],
const int viewport[4]);
/*! From world to image
* p
* point's coordinates expressed in world coordinates system
* q
* vector in which the result will be stored
* model_view_matrix
* The model view matrix expressed in line major order (OpenGL
* matrices are column major ordered)
* projection_matrix
* The projection matrix expressed in line major order (OpenGL
* matrices are column major ordered)
* viewport
* The viewport: x,y coordinates followed by width and height (OpenGL like viewport)
*/
LIB_GEOMETRY_EXPORT
void fromWorldToImage(const Vec3r& p, Vec3r& q, const real model_view_matrix[4][4], const real projection_matrix[4][4],
const int viewport[4]);
/*! From world to image
* p
* point's coordinates expressed in world coordinates system
* q
* vector in which the result will be stored
* transform
* The transformation matrix (gathering model view and projection),
* expressed in line major order (OpenGL matrices are column major ordered)
* viewport
* The viewport: x,y coordinates followed by width and height (OpenGL like viewport)
*/
LIB_GEOMETRY_EXPORT
void fromWorldToImage(const Vec3r& p,
Vec3r& q,
const real transform[4][4],
const int viewport[4]);
/*! From world to image
* p
* point's coordinates expressed in world coordinates system
* q
* vector in which the result will be stored
* transform
* The transformation matrix (gathering model view and projection),
* expressed in line major order (OpenGL matrices are column major ordered)
* viewport
* The viewport: x,y coordinates followed by width and height (OpenGL like viewport)
*/
LIB_GEOMETRY_EXPORT
void fromWorldToImage(const Vec3r& p, Vec3r& q, const real transform[4][4], const int viewport[4]);
/*! Projects from world coordinates to camera coordinates
* Returns the point's coordinates expressed in the camera's
* coordinates system.
* p
* point's coordinates expressed in world coordinates system
* q
* vector in which the result will be stored
* model_view_matrix
* The model view matrix expressed in line major order (OpenGL
* matrices are column major ordered)
*/
LIB_GEOMETRY_EXPORT
void fromWorldToCamera(const Vec3r& p,
Vec3r& q,
const real model_view_matrix[4][4]);
/*! Projects from World Coordinates to retina coordinates
* Returns the point's coordinates expressed in Retina system.
* p
* point's coordinates expressed in camera system
* q
* vector in which the result will be stored
* projection_matrix
* The projection matrix expressed in line major order (OpenGL
* matrices are column major ordered)
*/
LIB_GEOMETRY_EXPORT
void fromCameraToRetina(const Vec3r& p,
Vec3r& q,
const real projection_matrix[4][4]);
/*! From retina to image.
* Returns the coordinates expressed in Image coorinates system.
* p
* point's coordinates expressed in retina system
* q
* vector in which the result will be stored
* viewport
* The viewport: x,y coordinates followed by width and height (OpenGL like viewport).
*/
LIB_GEOMETRY_EXPORT
void fromRetinaToImage(const Vec3r& p,
Vec3r& q,
const int viewport[4]);
/*! From image to retina
* p
* point's coordinates expressed in image system
* q
* vector in which the result will be stored
* viewport
* The viewport: x,y coordinates followed by width and height (OpenGL like viewport).
*/
LIB_GEOMETRY_EXPORT
void fromImageToRetina(const Vec3r& p,
Vec3r& q,
const int viewport[4]);
/*! computes the coordinates of q in the camera coordinates system,
* using the known z coordinates of the 3D point.
* That means that this method does not inverse any matrices,
* it only computes X and Y from x,y and Z)
* p
* point's coordinates expressed in retina system
* q
* vector in which the result will be stored
* projection_matrix
* The projection matrix expressed in line major order (OpenGL
* matrices are column major ordered)
*/
LIB_GEOMETRY_EXPORT
void fromRetinaToCamera(const Vec3r& p,
Vec3r& q,
real z,
const real projection_matrix[4][4]);
/*! Projects from world coordinates to camera coordinates
* Returns the point's coordinates expressed in the camera's
* coordinates system.
* p
* point's coordinates expressed in world coordinates system
* q
* vector in which the result will be stored
* model_view_matrix
* The model view matrix expressed in line major order (OpenGL
* matrices are column major ordered)
*/
LIB_GEOMETRY_EXPORT
void fromWorldToCamera(const Vec3r& p, Vec3r& q, const real model_view_matrix[4][4]);
/*! Projects from camera coordinates to world coordinates
* Returns the point's coordinates expressed in the world's
* coordinates system.
* p
* point's coordinates expressed in the camera coordinates system
* q
* vector in which the result will be stored
* model_view_matrix
* The model view matrix expressed in line major order (OpenGL
* matrices are column major ordered)
*/
LIB_GEOMETRY_EXPORT
void fromCameraToWorld(const Vec3r& p,
Vec3r& q,
const real model_view_matrix[4][4]);
/*! Projects from World Coordinates to retina coordinates
* Returns the point's coordinates expressed in Retina system.
* p
* point's coordinates expressed in camera system
* q
* vector in which the result will be stored
* projection_matrix
* The projection matrix expressed in line major order (OpenGL
* matrices are column major ordered)
*/
LIB_GEOMETRY_EXPORT
void fromCameraToRetina(const Vec3r& p, Vec3r& q, const real projection_matrix[4][4]);
/*! From retina to image.
* Returns the coordinates expressed in Image coorinates system.
* p
* point's coordinates expressed in retina system
* q
* vector in which the result will be stored
* viewport
* The viewport: x,y coordinates followed by width and height (OpenGL like viewport).
*/
LIB_GEOMETRY_EXPORT
void fromRetinaToImage(const Vec3r& p, Vec3r& q, const int viewport[4]);
/*! From image to retina
* p
* point's coordinates expressed in image system
* q
* vector in which the result will be stored
* viewport
* The viewport: x,y coordinates followed by width and height (OpenGL like viewport).
*/
LIB_GEOMETRY_EXPORT
void fromImageToRetina(const Vec3r& p, Vec3r& q, const int viewport[4]);
/*! computes the coordinates of q in the camera coordinates system,
* using the known z coordinates of the 3D point.
* That means that this method does not inverse any matrices,
* it only computes X and Y from x,y and Z)
* p
* point's coordinates expressed in retina system
* q
* vector in which the result will be stored
* projection_matrix
* The projection matrix expressed in line major order (OpenGL
* matrices are column major ordered)
*/
LIB_GEOMETRY_EXPORT
void fromRetinaToCamera(const Vec3r& p, Vec3r& q, real z, const real projection_matrix[4][4]);
/*! Projects from camera coordinates to world coordinates
* Returns the point's coordinates expressed in the world's
* coordinates system.
* p
* point's coordinates expressed in the camera coordinates system
* q
* vector in which the result will be stored
* model_view_matrix
* The model view matrix expressed in line major order (OpenGL
* matrices are column major ordered)
*/
LIB_GEOMETRY_EXPORT
void fromCameraToWorld(const Vec3r& p, Vec3r& q, const real model_view_matrix[4][4]);
} // end of namespace GeomUtils
#endif // GEOMUTILS_H
#endif // __GEOMUTILS_H__

704
source/blender/freestyle/intern/geometry/Grid.cpp
View File

@ -1,392 +1,390 @@
/*
* ***** 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/geometry/Grid.cpp
* \ingroup freestyle
* \brief Base class to define a cell grid surrounding the bounding box of the scene
* \author Stephane Grabli
* \date 30/07/2002
*/
#include "Grid.h"
#include "BBox.h"
#include <cassert>
#include <stdexcept>
#include "BBox.h"
#include "Grid.h"
// Grid Visitors
/////////////////
void allOccludersGridVisitor::examineOccluder(Polygon3r *occ){
occluders_.push_back(occ);
void allOccludersGridVisitor::examineOccluder(Polygon3r *occ)
{
occluders_.push_back(occ);
}
static bool inBox(const Vec3r& inter, const Vec3r& box_min, const Vec3r& box_max){
if(((inter.x()>=box_min.x()) && (inter.x() <box_max.x()))
&& ((inter.y()>=box_min.y()) && (inter.y() <box_max.y()))
&& ((inter.z()>=box_min.z()) && (inter.z() <box_max.z()))
){
return true;
}
return false;
}
void firstIntersectionGridVisitor::examineOccluder(Polygon3r *occ){
// check whether the edge and the polygon plane are coincident:
//-------------------------------------------------------------
//first let us compute the plane equation.
Vec3r v1(((occ)->getVertices())[0]);
Vec3d normal((occ)->getNormal());
//soc unused - double d = -(v1 * normal);
double tmp_u, tmp_v, tmp_t;
if((occ)->rayIntersect(ray_org_, ray_dir_, tmp_t, tmp_u, tmp_v)){
if (fabs(ray_dir_ * normal) > 0.0001){
// Check whether the intersection is in the cell:
if(inBox(ray_org_+tmp_t*ray_dir_/ray_dir_.norm(), current_cell_->getOrigin(), current_cell_->getOrigin()+cell_size_)){
//Vec3d bboxdiag(_scene3d->bbox().getMax()-_scene3d->bbox().getMin());
//if ((t>1.0E-06*(min(min(bboxdiag.x(),bboxdiag.y()),bboxdiag.z()))) && (t<raylength)){
if(tmp_t < t_){
occluder_ = occ;
u_ = tmp_u;
v_ = tmp_v;
t_ = tmp_t;
}
}else{
occ->userdata2 = 0;
}
}
}
static bool inBox(const Vec3r& inter, const Vec3r& box_min, const Vec3r& box_max)
{
if (((inter.x() >= box_min.x()) && (inter.x() < box_max.x())) &&
((inter.y() >= box_min.y()) && (inter.y() < box_max.y())) &&
((inter.z() >= box_min.z()) && (inter.z() < box_max.z())))
{
return true;
}
return false;
}
bool firstIntersectionGridVisitor::stop(){
if(occluder_)
return true;
return false;
void firstIntersectionGridVisitor::examineOccluder(Polygon3r *occ)
{
// check whether the edge and the polygon plane are coincident:
//-------------------------------------------------------------
//first let us compute the plane equation.
Vec3r v1(((occ)->getVertices())[0]);
Vec3d normal((occ)->getNormal());
//soc unused - double d = -(v1 * normal);
double tmp_u, tmp_v, tmp_t;
if ((occ)->rayIntersect(ray_org_, ray_dir_, tmp_t, tmp_u, tmp_v)) {
if (fabs(ray_dir_ * normal) > 0.0001) {
// Check whether the intersection is in the cell:
if (inBox(ray_org_ + tmp_t * ray_dir_ / ray_dir_.norm(), current_cell_->getOrigin(),
current_cell_->getOrigin() + cell_size_))
{
#if 0
Vec3d bboxdiag(_scene3d->bbox().getMax() - _scene3d->bbox().getMin());
if ((t > 1.0e-06 * (min(min(bboxdiag.x(), bboxdiag.y()), bboxdiag.z()))) && (t < raylength)) {
#else
if (tmp_t < t_) {
#endif
occluder_ = occ;
u_ = tmp_u;
v_ = tmp_v;
t_ = tmp_t;
}
}
else {
occ->userdata2 = 0;
}
}
}
}
bool firstIntersectionGridVisitor::stop()
{
if (occluder_)
return true;
return false;
}
// Grid
/////////////////
void Grid::clear() {
if (_occluders.size() != 0) {
for(OccludersSet::iterator it = _occluders.begin();
it != _occluders.end();
it++) {
delete (*it);
}
_occluders.clear();
}
_size = Vec3r(0, 0, 0);
_cell_size = Vec3r(0, 0, 0);
_orig = Vec3r(0, 0, 0);
_cells_nb = Vec3u(0, 0, 0);
//_ray_occluders.clear();
}
void Grid::configure(const Vec3r& orig,
const Vec3r& size,
unsigned nb) {
_orig = orig;
Vec3r tmpSize=size;
// Compute the volume of the desired grid
real grid_vol = size[0] * size[1] * size[2];
if(grid_vol == 0){
double min=DBL_MAX;
int index=0;
int nzeros=0;
for(int i=0;i<3;++i){
if(size[i] == 0){
++nzeros;
index=i;
}
if((size[i]!=0) && (min>size[i])){
min=size[i];
}
}
if(nzeros>1){
throw std::runtime_error("Warning: the 3D grid has more than one null dimension");
}
tmpSize[index]=min;
_orig[index] = _orig[index]-min/2;
}
// Compute the desired volume of a single cell
real cell_vol = grid_vol / nb;
// The edge of such a cubic cell is cubic root of cellVolume
real edge = pow(cell_vol, 1.0 / 3.0);
// We compute the number of cells par edge
// such as we cover at least the whole box.
unsigned i;
for (i = 0; i < 3; i++)
_cells_nb[i] = (unsigned)floor(tmpSize[i] / edge) + 1;
_size = tmpSize;
for(i = 0; i < 3; i++)
_cell_size[i] = _size[i] / _cells_nb[i];
}
void Grid::insertOccluder(Polygon3r* occluder) {
const vector<Vec3r> vertices = occluder->getVertices();
if (vertices.size() == 0)
return;
// add this occluder to the grid's occluders list
addOccluder(occluder);
// find the bbox associated to this polygon
Vec3r min, max;
occluder->getBBox(min, max);
// Retrieve the cell x, y, z cordinates associated with these min and max
Vec3u imax, imin;
getCellCoordinates(max, imax);
getCellCoordinates(min, imin);
// We are now going to fill in the cells overlapping with the
// polygon bbox.
// If the polygon is a triangle (most of cases), we also
// check for each of these cells if it is overlapping with
// the triangle in order to only fill in the ones really overlapping
// the triangle.
unsigned i, x, y, z;
vector<Vec3r>::const_iterator it;
Vec3u coord;
if (vertices.size() == 3) { // Triangle case
Vec3r triverts[3];
i = 0;
for(it = vertices.begin();
it != vertices.end();
it++) {
triverts[i] = Vec3r(*it);
i++;
}
Vec3r boxmin, boxmax;
for (z = imin[2]; z <= imax[2]; z++)
for (y = imin[1]; y <= imax[1]; y++)
for (x = imin[0]; x <= imax[0]; x++) {
coord[0] = x;
coord[1] = y;
coord[2] = z;
// We retrieve the box coordinates of the current cell
getCellBox(coord, boxmin, boxmax);
// We check whether the triangle and the box ovewrlap:
Vec3r boxcenter((boxmin + boxmax) / 2.0);
Vec3r boxhalfsize(_cell_size / 2.0);
if (GeomUtils::overlapTriangleBox(boxcenter, boxhalfsize, triverts)) {
// We must then create the Cell and add it to the cells list
// if it does not exist yet.
// We must then add the occluder to the occluders list of this cell.
Cell* cell = getCell(coord);
if (!cell) {
cell = new Cell(boxmin);
fillCell(coord, *cell);
}
cell->addOccluder(occluder);
}
void Grid::clear()
{
if (_occluders.size() != 0) {
for (OccludersSet::iterator it = _occluders.begin(); it != _occluders.end(); it++) {
delete (*it);
}
_occluders.clear();
}
}
else { // The polygon is not a triangle, we add all the cells overlapping the polygon bbox.
for (z = imin[2]; z <= imax[2]; z++)
for (y = imin[1]; y <= imax[1]; y++)
for (x = imin[0]; x <= imax[0]; x++) {
coord[0] = x;
coord[1] = y;
coord[2] = z;
Cell* cell = getCell(coord);
if (!cell) {
Vec3r orig;
getCellOrigin(coord, orig);
cell = new Cell(orig);
fillCell(coord, *cell);
}
cell->addOccluder(occluder);
_size = Vec3r(0, 0, 0);
_cell_size = Vec3r(0, 0, 0);
_orig = Vec3r(0, 0, 0);
_cells_nb = Vec3u(0, 0, 0);
//_ray_occluders.clear();
}
void Grid::configure(const Vec3r& orig, const Vec3r& size, unsigned nb)
{
_orig = orig;
Vec3r tmpSize = size;
// Compute the volume of the desired grid
real grid_vol = size[0] * size[1] * size[2];
if (grid_vol == 0) {
double min = DBL_MAX;
int index = 0;
int nzeros = 0;
for (int i = 0; i < 3; ++i) {
if (size[i] == 0) {
++nzeros;
index = i;
}
if ((size[i] != 0) && (min > size[i])) {
min = size[i];
}
}
if (nzeros > 1) {
throw std::runtime_error("Warning: the 3D grid has more than one null dimension");
}
tmpSize[index] = min;
_orig[index] = _orig[index] - min / 2;
}
}
// Compute the desired volume of a single cell
real cell_vol = grid_vol / nb;
// The edge of such a cubic cell is cubic root of cellVolume
real edge = pow(cell_vol, 1.0 / 3.0);
// We compute the number of cells par edge such as we cover at least the whole box.
unsigned i;
for (i = 0; i < 3; i++)
_cells_nb[i] = (unsigned)floor(tmpSize[i] / edge) + 1;
_size = tmpSize;
for (i = 0; i < 3; i++)
_cell_size[i] = _size[i] / _cells_nb[i];
}
bool Grid::nextRayCell(Vec3u& current_cell, Vec3u& next_cell) {
next_cell = current_cell;
real t_min, t;
unsigned i;
t_min = FLT_MAX; // init tmin with handle of the case where one or 2 _u[i] = 0.
unsigned coord = 0; // predominant coord(0=x, 1=y, 2=z)
void Grid::insertOccluder(Polygon3r* occluder)
{
const vector<Vec3r> vertices = occluder->getVertices();
if (vertices.size() == 0)
return;
// add this occluder to the grid's occluders list
addOccluder(occluder);
// using a parametric equation of
// a line : B = A + t u, we find
// the tx, ty and tz respectively coresponding
// to the intersections with the plans:
// x = _cell_size[0], y = _cell_size[1], z = _cell_size[2]
for (i = 0; i < 3; i++) {
if (_ray_dir[i] == 0)
continue;
if (_ray_dir[i] > 0)
t = (_cell_size[i] - _pt[i]) / _ray_dir[i];
else
t = -_pt[i] / _ray_dir[i];
if (t < t_min) {
t_min = t;
coord = i;
}
}
// find the bbox associated to this polygon
Vec3r min, max;
occluder->getBBox(min, max);
// We use the parametric line equation and
// the found t (tamx) to compute the
// B coordinates:
Vec3r pt_tmp(_pt);
_pt = pt_tmp + t_min * _ray_dir;
// We express B coordinates in the next cell
// coordinates system. We just have to
// set the coordinate coord of B to 0
// of _CellSize[coord] depending on the sign
// of _u[coord]
if (_ray_dir[coord] > 0) {
next_cell[coord]++;
_pt[coord] -= _cell_size[coord];
// if we are out of the grid, we must stop
if (next_cell[coord] >= _cells_nb[coord])
return false;
}
else {
int tmp = next_cell[coord] - 1;
_pt[coord] = _cell_size[coord];
if (tmp < 0)
return false;
next_cell[coord]--;
}
// Retrieve the cell x, y, z cordinates associated with these min and max
Vec3u imax, imin;
getCellCoordinates(max, imax);
getCellCoordinates(min, imin);
_t += t_min;
if (_t >= _t_end)
return false;
// We are now going to fill in the cells overlapping with the polygon bbox.
// If the polygon is a triangle (most of cases), we also check for each of these cells if it is overlapping with
// the triangle in order to only fill in the ones really overlapping the triangle.
return true;
unsigned i, x, y, z;
vector<Vec3r>::const_iterator it;
Vec3u coord;
if (vertices.size() == 3) { // Triangle case
Vec3r triverts[3];
i = 0;
for (it = vertices.begin(); it != vertices.end(); it++) {
triverts[i] = Vec3r(*it);
i++;
}
Vec3r boxmin, boxmax;
for (z = imin[2]; z <= imax[2]; z++) {
for (y = imin[1]; y <= imax[1]; y++) {
for (x = imin[0]; x <= imax[0]; x++) {
coord[0] = x;
coord[1] = y;
coord[2] = z;
// We retrieve the box coordinates of the current cell
getCellBox(coord, boxmin, boxmax);
// We check whether the triangle and the box ovewrlap:
Vec3r boxcenter((boxmin + boxmax) / 2.0);
Vec3r boxhalfsize(_cell_size / 2.0);
if (GeomUtils::overlapTriangleBox(boxcenter, boxhalfsize, triverts)) {
// We must then create the Cell and add it to the cells list if it does not exist yet.
// We must then add the occluder to the occluders list of this cell.
Cell* cell = getCell(coord);
if (!cell) {
cell = new Cell(boxmin);
fillCell(coord, *cell);
}
cell->addOccluder(occluder);
}
}
}
}
}
else { // The polygon is not a triangle, we add all the cells overlapping the polygon bbox.
for (z = imin[2]; z <= imax[2]; z++) {
for (y = imin[1]; y <= imax[1]; y++) {
for (x = imin[0]; x <= imax[0]; x++) {
coord[0] = x;
coord[1] = y;
coord[2] = z;
Cell* cell = getCell(coord);
if (!cell) {
Vec3r orig;
getCellOrigin(coord, orig);
cell = new Cell(orig);
fillCell(coord, *cell);
}
cell->addOccluder(occluder);
}
}
}
}
}
void Grid::castRay(const Vec3r& orig,
const Vec3r& end,
OccludersSet& occluders,
unsigned timestamp) {
initRay(orig, end, timestamp);
allOccludersGridVisitor visitor(occluders);
castRayInternal(visitor);
bool Grid::nextRayCell(Vec3u& current_cell, Vec3u& next_cell)
{
next_cell = current_cell;
real t_min, t;
unsigned i;
t_min = FLT_MAX; // init tmin with handle of the case where one or 2 _u[i] = 0.
unsigned coord = 0; // predominant coord(0=x, 1=y, 2=z)
// using a parametric equation of a line : B = A + t u, we find the tx, ty and tz respectively coresponding
// to the intersections with the plans:
// x = _cell_size[0], y = _cell_size[1], z = _cell_size[2]
for (i = 0; i < 3; i++) {
if (_ray_dir[i] == 0)
continue;
if (_ray_dir[i] > 0)
t = (_cell_size[i] - _pt[i]) / _ray_dir[i];
else
t = -_pt[i] / _ray_dir[i];
if (t < t_min) {
t_min = t;
coord = i;
}
}
// We use the parametric line equation and the found t (tamx) to compute the B coordinates:
Vec3r pt_tmp(_pt);
_pt = pt_tmp + t_min * _ray_dir;
// We express B coordinates in the next cell coordinates system. We just have to
// set the coordinate coord of B to 0 of _CellSize[coord] depending on the sign of _u[coord]
if (_ray_dir[coord] > 0) {
next_cell[coord]++;
_pt[coord] -= _cell_size[coord];
// if we are out of the grid, we must stop
if (next_cell[coord] >= _cells_nb[coord])
return false;
}
else {
int tmp = next_cell[coord] - 1;
_pt[coord] = _cell_size[coord];
if (tmp < 0)
return false;
next_cell[coord]--;
}
_t += t_min;
if (_t >= _t_end)
return false;
return true;
}
void Grid::castInfiniteRay(const Vec3r& orig,
const Vec3r& dir,
OccludersSet& occluders,
unsigned timestamp) {
Vec3r end = Vec3r(orig + FLT_MAX * dir / dir.norm());
bool inter = initInfiniteRay(orig, dir, timestamp);
if(!inter)
return;
allOccludersGridVisitor visitor(occluders);
castRayInternal(visitor);
void Grid::castRay(const Vec3r& orig, const Vec3r& end, OccludersSet& occluders, unsigned timestamp)
{
initRay(orig, end, timestamp);
allOccludersGridVisitor visitor(occluders);
castRayInternal(visitor);
}
Polygon3r* Grid::castRayToFindFirstIntersection(const Vec3r& orig,
const Vec3r& dir,
double& t,
double& u,
double& v,
unsigned timestamp){
Polygon3r *occluder = 0;
Vec3r end = Vec3r(orig + FLT_MAX * dir / dir.norm());
bool inter = initInfiniteRay(orig, dir, timestamp);
if(!inter){
return 0;
}
firstIntersectionGridVisitor visitor(orig,dir,_cell_size);
castRayInternal(visitor);
void Grid::castInfiniteRay(const Vec3r& orig, const Vec3r& dir, OccludersSet& occluders, unsigned timestamp)
{
Vec3r end = Vec3r(orig + FLT_MAX * dir / dir.norm());
bool inter = initInfiniteRay(orig, dir, timestamp);
if (!inter)
return;
allOccludersGridVisitor visitor(occluders);
castRayInternal(visitor);
}
Polygon3r* Grid::castRayToFindFirstIntersection(const Vec3r& orig, const Vec3r& dir, double& t,
double& u, double& v, unsigned timestamp)
{
Polygon3r *occluder = 0;
Vec3r end = Vec3r(orig + FLT_MAX * dir / dir.norm());
bool inter = initInfiniteRay(orig, dir, timestamp);
if (!inter) {
return 0;
}
firstIntersectionGridVisitor visitor(orig, dir, _cell_size);
castRayInternal(visitor);
// ARB: This doesn't work, because occluders are unordered within any cell
// visitor.occluder() will be an occluder, but we have no guarantee
// it will be the *first* occluder.
// visitor.occluder() will be an occluder, but we have no guarantee it will be the *first* occluder.
// I assume that is the reason this code is not actually used for FindOccludee.
occluder = visitor.occluder();
t = visitor.t_;
u = visitor.u_;
v = visitor.v_;
return occluder;
occluder = visitor.occluder();
t = visitor.t_;
u = visitor.u_;
v = visitor.v_;
return occluder;
}
void Grid::initRay (const Vec3r &orig,
const Vec3r& end,
unsigned timestamp) {
_ray_dir = end - orig;
_t_end = _ray_dir.norm();
_t = 0;
_ray_dir.normalize();
_timestamp = timestamp;
for(unsigned i = 0; i < 3; i++) {
_current_cell[i] = (unsigned)floor((orig[i] - _orig[i]) / _cell_size[i]);
//soc unused - unsigned u = _current_cell[i];
_pt[i] = orig[i] - _orig[i] - _current_cell[i] * _cell_size[i];
}
//_ray_occluders.clear();
void Grid::initRay (const Vec3r &orig, const Vec3r& end, unsigned timestamp)
{
_ray_dir = end - orig;
_t_end = _ray_dir.norm();
_t = 0;
_ray_dir.normalize();
_timestamp = timestamp;
for (unsigned i = 0; i < 3; i++) {
_current_cell[i] = (unsigned)floor((orig[i] - _orig[i]) / _cell_size[i]);
//soc unused - unsigned u = _current_cell[i];
_pt[i] = orig[i] - _orig[i] - _current_cell[i] * _cell_size[i];
}
//_ray_occluders.clear();
}
bool Grid::initInfiniteRay (const Vec3r &orig,
const Vec3r& dir,
unsigned timestamp) {
_ray_dir = dir;
_t_end = FLT_MAX;
_t = 0;
_ray_dir.normalize();
_timestamp = timestamp;
bool Grid::initInfiniteRay (const Vec3r &orig, const Vec3r& dir, unsigned timestamp) {
_ray_dir = dir;
_t_end = FLT_MAX;
_t = 0;
_ray_dir.normalize();
_timestamp = timestamp;
// check whether the origin is in or out the box:
Vec3r boxMin(_orig);
Vec3r boxMax(_orig+_size);
BBox<Vec3r> box(boxMin, boxMax);
if(box.inside(orig)){
for(unsigned i = 0; i < 3; i++) {
_current_cell[i] = (unsigned)floor((orig[i] - _orig[i]) / _cell_size[i]);
//soc unused - unsigned u = _current_cell[i];
_pt[i] = orig[i] - _orig[i] - _current_cell[i] * _cell_size[i];
}
}else{
// is the ray intersecting the box?
real tmin(-1.0), tmax(-1.0);
if(GeomUtils::intersectRayBBox(orig, _ray_dir, boxMin, boxMax, 0, _t_end, tmin, tmax)){
assert(tmin != -1.0);
Vec3r newOrig = orig + tmin*_ray_dir;
for(unsigned i = 0; i < 3; i++) {
_current_cell[i] = (unsigned)floor((newOrig[i] - _orig[i]) / _cell_size[i]);
if(_current_cell[i] == _cells_nb[i])
_current_cell[i] = _cells_nb[i] - 1;
//soc unused - unsigned u = _current_cell[i];
_pt[i] = newOrig[i] - _orig[i] - _current_cell[i] * _cell_size[i];
}
}else{
return false;
}
}
//_ray_occluders.clear();
return true;
// check whether the origin is in or out the box:
Vec3r boxMin(_orig);
Vec3r boxMax(_orig + _size);
BBox<Vec3r> box(boxMin, boxMax);
if (box.inside(orig)) {
for (unsigned int i = 0; i < 3; i++) {
_current_cell[i] = (unsigned int)floor((orig[i] - _orig[i]) / _cell_size[i]);
//soc unused - unsigned u = _current_cell[i];
_pt[i] = orig[i] - _orig[i] - _current_cell[i] * _cell_size[i];
}
}
else {
// is the ray intersecting the box?
real tmin(-1.0), tmax(-1.0);
if (GeomUtils::intersectRayBBox(orig, _ray_dir, boxMin, boxMax, 0, _t_end, tmin, tmax)) {
assert(tmin != -1.0);
Vec3r newOrig = orig + tmin * _ray_dir;
for (unsigned int i = 0; i < 3; i++) {
_current_cell[i] = (unsigned)floor((newOrig[i] - _orig[i]) / _cell_size[i]);
if (_current_cell[i] == _cells_nb[i])
_current_cell[i] = _cells_nb[i] - 1;
//soc unused - unsigned u = _current_cell[i];
_pt[i] = newOrig[i] - _orig[i] - _current_cell[i] * _cell_size[i];
}
}
else {
return false;
}
}
//_ray_occluders.clear();
return true;
}

591
source/blender/freestyle/intern/geometry/Grid.h
View File

@ -1,49 +1,54 @@
//
// Filename : Grid.h
// Author(s) : Stephane Grabli
// Purpose : Base class to define a cell grid surrounding
// the bounding box of the scene
// Date of creation : 30/07/2002
//
///////////////////////////////////////////////////////////////////////////////
/*
* ***** 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 __GRID_H__
#define __GRID_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/geometry/Grid.h
* \ingroup freestyle
* \brief Base class to define a cell grid surrounding the bounding box of the scene
* \author Stephane Grabli
* \date 30/07/2002
*/
#ifndef GRID_H
# define GRID_H
#include <cstring> // for memset
#include <float.h>
#include <vector>
# include <cstring> // for memset
# include <float.h>
# include <vector>
# include "../system/FreestyleConfig.h"
# include "GeomUtils.h"
# include "Geom.h"
# include "Polygon.h"
#include "Geom.h"
#include "GeomUtils.h"
#include "Polygon.h"
#include "../system/FreestyleConfig.h"
using namespace std;
using namespace Geometry;
typedef vector<Polygon3r*> OccludersSet;
typedef vector<Polygon3r*> OccludersSet;
//
// Class to define cells used by the regular grid
@ -52,84 +57,102 @@ typedef vector<Polygon3r*> OccludersSet;
class LIB_GEOMETRY_EXPORT Cell
{
public:
Cell(Vec3r& orig) {
_orig = orig;
}
public:
Cell(Vec3r& orig) {
_orig = orig;
}
virtual ~Cell() {}
virtual ~Cell() {}
inline void addOccluder(Polygon3r* o) {
if (o)
_occluders.push_back(o);
}
inline void addOccluder(Polygon3r* o) {
if (o)
_occluders.push_back(o);
}
inline const Vec3r& getOrigin() {
return _orig;
}
inline const Vec3r& getOrigin() {
return _orig;
}
inline OccludersSet& getOccluders() {
return _occluders;
}
private:
inline OccludersSet& getOccluders() {
return _occluders;
}
Vec3r _orig;
OccludersSet _occluders;
private:
Vec3r _orig;
OccludersSet _occluders;
};
class GridVisitor{
class GridVisitor
{
public:
virtual ~GridVisitor() {}; //soc
virtual void discoverCell(Cell *cell) {}
virtual void examineOccluder(Polygon3r *occ) {}
virtual void finishCell(Cell *cell) {}
virtual bool stop() {return false;}
virtual void discoverCell(Cell *cell) {}
virtual void examineOccluder(Polygon3r *occ) {}
virtual void finishCell(Cell *cell) {}
virtual bool stop() {
return false;
}
};
/*! Gathers all the occluders belonging to the cells
* traversed by the ray */
class allOccludersGridVisitor : public GridVisitor{
/*! Gathers all the occluders belonging to the cells traversed by the ray */
class allOccludersGridVisitor : public GridVisitor
{
public:
allOccludersGridVisitor(OccludersSet& occluders)
:GridVisitor(), occluders_(occluders){}
virtual void examineOccluder(Polygon3r *occ);
allOccludersGridVisitor(OccludersSet& occluders) : GridVisitor(), occluders_(occluders) {}
OccludersSet& occluders() {return occluders_;}
void clear() {occluders_.clear();}
virtual void examineOccluder(Polygon3r *occ);
OccludersSet& occluders() {
return occluders_;
}
void clear() {
occluders_.clear();
}
private:
OccludersSet& occluders_;
OccludersSet& occluders_;
};
/*! Finds the first intersection and breaks. The occluder and
* the intersection information are stored and accessible.
/*! Finds the first intersection and breaks.
* The occluder and the intersection information are stored and accessible.
*/
class firstIntersectionGridVisitor : public GridVisitor {
class firstIntersectionGridVisitor : public GridVisitor
{
//soc - changed order to remove warnings
public:
double u_, v_, t_;
double u_, v_, t_;
private:
Polygon3r *occluder_;
Polygon3r *occluder_;
Vec3r ray_org_, ray_dir_, cell_size_;
Cell * current_cell_;
Cell *current_cell_;
public:
firstIntersectionGridVisitor(const Vec3r& ray_org, const Vec3r& ray_dir, const Vec3r& cell_size) :
GridVisitor(), u_(0),v_(0),t_(DBL_MAX),
occluder_(0),
ray_org_(ray_org), ray_dir_(ray_dir), cell_size_(cell_size),
current_cell_(0) {}
virtual ~firstIntersectionGridVisitor() {}
firstIntersectionGridVisitor(const Vec3r& ray_org, const Vec3r& ray_dir, const Vec3r& cell_size) :
GridVisitor(), u_(0),v_(0),t_(DBL_MAX), occluder_(0), ray_org_(ray_org), ray_dir_(ray_dir),
cell_size_(cell_size), current_cell_(0)
{
}
virtual void discoverCell(Cell *cell) {current_cell_=cell;}
virtual void examineOccluder(Polygon3r *occ);
virtual bool stop();
virtual ~firstIntersectionGridVisitor() {}
Polygon3r * occluder() {return occluder_;}
virtual void discoverCell(Cell *cell) {
current_cell_ = cell;
}
virtual void examineOccluder(Polygon3r *occ);
virtual bool stop();
Polygon3r *occluder() {
return occluder_;
}
};
//
@ -140,236 +163,197 @@ public:
class LIB_GEOMETRY_EXPORT Grid
{
public:
/*! Builds a Grid. Must be followed by a call to configure() */
Grid() {}
/*! Builds a Grid
* Must be followed by a call to configure()
*/
Grid() {}
virtual ~Grid() {
clear();
}
virtual ~Grid() {
clear();
}
/*! clears the grid
* Deletes all the cells, clears the hashtable, resets size, size of cell, number of cells.
*/
virtual void clear();
/*! clears the grid
* Deletes all the cells, clears the hashtable,
* resets size, size of cell, number of cells.
*/
virtual void clear();
/*! Sets the different parameters of the grid
* orig
* The grid origin
* size
* The grid's dimensions
* nb
* The number of cells of the grid
*/
virtual void configure(const Vec3r& orig, const Vec3r& size, unsigned nb);
/*! Sets the different parameters of the grid
* orig
* The grid origin
* size
* The grid's dimensions
* nb
* The number of cells of the grid
*/
virtual void configure(const Vec3r& orig, const Vec3r& size, unsigned nb);
/*! returns a vector of integer containing the
* coordinates of the cell containing the point
* passed as argument
* p
* The point for which we're looking the cell
*/
inline void getCellCoordinates(const Vec3r& p, Vec3u& res) {
int tmp;
for (int i = 0; i < 3; i++) {
tmp = (int)((p[i] - _orig[i]) / _cell_size[i]);
if (tmp < 0)
res[i] = 0;
else if ((unsigned)tmp >= _cells_nb[i])
res[i] = _cells_nb[i] - 1;
else
res[i] = tmp;
}
}
/*! returns a vector of integer containing the coordinates of the cell containing the point passed as argument
* p
* The point for which we're looking the cell
*/
inline void getCellCoordinates(const Vec3r& p, Vec3u& res) {
int tmp;
for (int i = 0; i < 3; i++) {
tmp = (int)((p[i] - _orig[i]) / _cell_size[i]);
if (tmp < 0)
res[i] = 0;
else if ((unsigned int)tmp >= _cells_nb[i])
res[i] = _cells_nb[i] - 1;
else
res[i] = tmp;
}
}
/*! Fills the case corresponding to coord with the cell */
virtual void fillCell(const Vec3u& coord, Cell& cell) = 0;
/*! Fills the case corresponding to coord with the cell */
virtual void fillCell(const Vec3u& coord, Cell& cell) = 0;
/*! returns the cell whose coordinates
* are pased as argument
*/
virtual Cell* getCell(const Vec3u& coord) = 0;
/*! returns the cell whose coordinates are pased as argument */
virtual Cell* getCell(const Vec3u& coord) = 0;
/*! returns the cell containing the point
* passed as argument. If the cell is empty
* (contains no occluder), NULL is returned
* p
* The point for which we're looking the cell
*/
inline Cell* getCell(const Vec3r& p) {
Vec3u coord;
getCellCoordinates(p, coord);
return getCell(coord);
}
/*! returns the cell containing the point passed as argument. If the cell is empty (contains no occluder),
* NULL is returned
* p
* The point for which we're looking the cell
*/
inline Cell* getCell(const Vec3r& p) {
Vec3u coord;
getCellCoordinates(p, coord);
return getCell(coord);
}
/*! Retrieves the x,y,z coordinates of the origin of the cell whose coordinates (i,j,k)
* is passed as argument
* cell_coord
* i,j,k integer coordinates for the cell
* orig
* x,y,x vector to be filled in with the cell origin's coordinates
*/
inline void getCellOrigin(const Vec3u& cell_coord, Vec3r& orig) {
for (unsigned i = 0; i < 3; i++)
orig[i] = _orig[i] + cell_coord[i] * _cell_size[i];
}
/*! Retrieves the x,y,z coordinates of the origin of the cell whose coordinates (i,j,k) is passed as argument
* cell_coord
* i,j,k integer coordinates for the cell
* orig
* x,y,x vector to be filled in with the cell origin's coordinates
*/
inline void getCellOrigin(const Vec3u& cell_coord, Vec3r& orig) {
for (unsigned int i = 0; i < 3; i++)
orig[i] = _orig[i] + cell_coord[i] * _cell_size[i];
}
/*! Retrieves the box corresponding to the cell whose coordinates
* are passed as argument.
* cell_coord
* i,j,k integer coordinates for the cell
* min_out
* The min x,y,x vector of the box. Filled in by the method.
* max_out
* The max x,y,z coordinates of the box. Filled in by the method.
*/
inline void getCellBox(const Vec3u& cell_coord, Vec3r& min_out, Vec3r& max_out) {
getCellOrigin(cell_coord, min_out);
max_out = min_out + _cell_size;
}
/*! Retrieves the box corresponding to the cell whose coordinates are passed as argument.
* cell_coord
* i,j,k integer coordinates for the cell
* min_out
* The min x,y,x vector of the box. Filled in by the method.
* max_out
* The max x,y,z coordinates of the box. Filled in by the method.
*/
inline void getCellBox(const Vec3u& cell_coord, Vec3r& min_out, Vec3r& max_out) {
getCellOrigin(cell_coord, min_out);
max_out = min_out + _cell_size;
}
/*! inserts a convex polygon occluder
* This method is quite coarse insofar as it
* adds all cells intersecting the polygon bounding box
* convex_poly
* The list of 3D points constituing a convex polygon
*/
void insertOccluder(Polygon3r * convex_poly);
/*! inserts a convex polygon occluder
* This method is quite coarse insofar as it adds all cells intersecting the polygon bounding box
* convex_poly
* The list of 3D points constituing a convex polygon
*/
void insertOccluder(Polygon3r * convex_poly);
/*! Adds an occluder to the list of occluders */
void addOccluder(Polygon3r* occluder) {
_occluders.push_back(occluder);
}
/*! Adds an occluder to the list of occluders */
void addOccluder(Polygon3r* occluder) {
_occluders.push_back(occluder);
}
/*! Casts a ray between a starting point and an ending point
* Returns the list of occluders contained
* in the cells intersected by this ray
* Starts with a call to InitRay.
*/
void castRay(const Vec3r& orig,
const Vec3r& end,
OccludersSet& occluders,
unsigned timestamp);
// Prepares to cast ray without generating OccludersSet
void initAcceleratedRay(const Vec3r& orig,
const Vec3r& end,
unsigned timestamp);
/*! Casts a ray between a starting point and an ending point
* Returns the list of occluders contained in the cells intersected by this ray
* Starts with a call to InitRay.
*/
void castRay(const Vec3r& orig, const Vec3r& end, OccludersSet& occluders, unsigned timestamp);
/*! Casts an infinite ray (still finishing at the end of the grid) from a starting point and in a given direction.
* Returns the list of occluders contained
* in the cells intersected by this ray
* Starts with a call to InitRay.
*/
void castInfiniteRay(const Vec3r& orig,
const Vec3r& dir,
OccludersSet& occluders,
unsigned timestamp);
// Prepares to cast ray without generating OccludersSet.
bool initAcceleratedInfiniteRay(const Vec3r& orig,
const Vec3r& dir,
unsigned timestamp);
// Prepares to cast ray without generating OccludersSet
void initAcceleratedRay(const Vec3r& orig, const Vec3r& end, unsigned timestamp);
/*! Casts an infinite ray (still finishing at the end of the grid) from a starting point and in a given direction.
* Returns the first intersection (occluder,t,u,v) or null.
* Starts with a call to InitRay.
*/
Polygon3r * castRayToFindFirstIntersection(const Vec3r& orig,
const Vec3r& dir,
double& t,
double& u,
double& v,
unsigned timestamp);
/*! Casts an infinite ray (still finishing at the end of the grid) from a starting point and in a given direction.
* Returns the list of occluders contained in the cells intersected by this ray
* Starts with a call to InitRay.
*/
void castInfiniteRay(const Vec3r& orig, const Vec3r& dir, OccludersSet& occluders, unsigned timestamp);
// Prepares to cast ray without generating OccludersSet.
bool initAcceleratedInfiniteRay(const Vec3r& orig, const Vec3r& dir, unsigned timestamp);
/*! Casts an infinite ray (still finishing at the end of the grid) from a starting point and in a given direction.
* Returns the first intersection (occluder,t,u,v) or null.
* Starts with a call to InitRay.
*/
Polygon3r * castRayToFindFirstIntersection(const Vec3r& orig, const Vec3r& dir, double& t,
double& u, double& v, unsigned timestamp);
/*! Init all structures and values for computing
* the cells intersected by this new ray
*/
void initRay (const Vec3r &orig,
const Vec3r& end,
unsigned timestamp);
/*! Init all structures and values for computing the cells intersected by this new ray */
void initRay(const Vec3r &orig, const Vec3r& end, unsigned timestamp);
/*! Init all structures and values for computing
* the cells intersected by this infinite ray.
* Returns false if the ray doesn't intersect the
* grid.
*/
bool initInfiniteRay (const Vec3r &orig,
const Vec3r& dir,
unsigned timestamp);
/*! Init all structures and values for computing the cells intersected by this infinite ray.
* Returns false if the ray doesn't intersect the grid.
*/
bool initInfiniteRay(const Vec3r &orig, const Vec3r& dir, unsigned timestamp);
/*! Accessors */
inline const Vec3r& getOrigin() const {
return _orig;
}
inline Vec3r gridSize() const {
return _size;
}
inline Vec3r getCellSize() const {
return _cell_size;
}
//ARB profiling only:
inline OccludersSet* getOccluders() {
return &_occluders;
}
void displayDebug() {
cerr << "Cells nb : " << _cells_nb << endl;
cerr << "Cell size : " << _cell_size << endl;
cerr << "Origin : " << _orig << endl;
cerr << "Occluders nb : " << _occluders.size() << endl;
}
/*! Accessors */
inline const Vec3r& getOrigin() const {
return _orig;
}
protected:
inline Vec3r gridSize() const {
return _size;
}
/*! Core of castRay and castInfiniteRay, find occluders
* along the given ray
*/
inline void castRayInternal(GridVisitor& visitor) {
Cell* current_cell = NULL;
do {
current_cell = getCell(_current_cell);
if (current_cell){
visitor.discoverCell(current_cell);
OccludersSet& occluders = current_cell->getOccluders(); // FIXME: I had forgotten the ref &
for (OccludersSet::iterator it = occluders.begin();
it != occluders.end();
it++) {
if ((unsigned long)(*it)->userdata2 != _timestamp) {
(*it)->userdata2 = (void*)_timestamp;
visitor.examineOccluder(*it);
}
}
visitor.finishCell(current_cell);
}
} while ((!visitor.stop()) && (nextRayCell(_current_cell, _current_cell)));
}
inline Vec3r getCellSize() const {
return _cell_size;
}
/*! returns the cell next to the cell
* passed as argument.
*/
bool nextRayCell(Vec3u& current_cell, Vec3u& next_cell);
//ARB profiling only:
inline OccludersSet* getOccluders() {
return &_occluders;
}
unsigned _timestamp;
void displayDebug() {
cerr << "Cells nb : " << _cells_nb << endl;
cerr << "Cell size : " << _cell_size << endl;
cerr << "Origin : " << _orig << endl;
cerr << "Occluders nb : " << _occluders.size() << endl;
}
Vec3u _cells_nb; // number of cells for x,y,z axis
Vec3r _cell_size; // cell x,y,z dimensions
Vec3r _size; // grid x,y,x dimensions
Vec3r _orig; // grid origin
protected:
/*! Core of castRay and castInfiniteRay, find occluders along the given ray */
inline void castRayInternal(GridVisitor& visitor) {
Cell *current_cell = NULL;
do {
current_cell = getCell(_current_cell);
if (current_cell) {
visitor.discoverCell(current_cell);
OccludersSet& occluders = current_cell->getOccluders(); // FIXME: I had forgotten the ref &
for (OccludersSet::iterator it = occluders.begin(); it != occluders.end(); it++) {
if ((unsigned long)(*it)->userdata2 != _timestamp) {
(*it)->userdata2 = (void*)_timestamp;
visitor.examineOccluder(*it);
}
}
visitor.finishCell(current_cell);
}
} while ((!visitor.stop()) && (nextRayCell(_current_cell, _current_cell)));
}
Vec3r _ray_dir; // direction vector for the ray
Vec3u _current_cell; // The current cell being processed (designated by its 3 coordinates)
Vec3r _pt; // Points corresponding to the incoming and outgoing intersections
// of one cell with the ray
real _t_end; // To know when we are at the end of the ray
real _t;
//OccludersSet _ray_occluders; // Set storing the occluders contained in the cells traversed by a ray
OccludersSet _occluders; // List of all occluders inserted in the grid
/*! returns the cell next to the cell passed as argument. */
bool nextRayCell(Vec3u& current_cell, Vec3u& next_cell);
unsigned int _timestamp;
Vec3u _cells_nb; // number of cells for x,y,z axis
Vec3r _cell_size; // cell x,y,z dimensions
Vec3r _size; // grid x,y,x dimensions
Vec3r _orig; // grid origin
Vec3r _ray_dir; // direction vector for the ray
Vec3u _current_cell; // The current cell being processed (designated by its 3 coordinates)
Vec3r _pt; // Points corresponding to the incoming and outgoing intersections of one cell with the ray
real _t_end; // To know when we are at the end of the ray
real _t;
//OccludersSet _ray_occluders; // Set storing the occluders contained in the cells traversed by a ray
OccludersSet _occluders; // List of all occluders inserted in the grid
};
//
@ -378,15 +362,16 @@ public:
///////////////////////////////////////////////////////////////////////////////
class VirtualOccludersSet {
public:
VirtualOccludersSet(Grid& _grid) : grid (_grid) {};
Polygon3r* begin();
Polygon3r* next();
Polygon3r* next(bool stopOnNewCell);
private:
Polygon3r* firstOccluderFromNextCell();
Grid& grid;
OccludersSet::iterator it, end;
public:
VirtualOccludersSet(Grid& _grid) : grid (_grid) {};
Polygon3r* begin();
Polygon3r* next();
Polygon3r* next(bool stopOnNewCell);
private:
Polygon3r* firstOccluderFromNextCell();
Grid& grid;
OccludersSet::iterator it, end;
};
#endif // GRID_H
#endif // __GRID_H__

87
source/blender/freestyle/intern/geometry/GridHelpers.cpp
View File

@ -1,49 +1,52 @@
//
// Filename : GridHelpers.cpp
// 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 *****
*/
//
// 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/geometry/GridHelpers.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 <math.h>
#include "GridHelpers.h"
void GridHelpers::getDefaultViewProscenium(real viewProscenium[4]) {
void GridHelpers::getDefaultViewProscenium(real viewProscenium[4])
{
// Get proscenium boundary for culling
// bufferZone determines the amount by which the area processed
// should exceed the actual image area. This is intended to
// avoid visible artifacts generated along the proscenium edge.
// Perhaps this is no longer needed now that entire view edges
// are culled at once, since that theoretically should eliminate
// visible artifacts.
// To the extent it is still useful, bufferZone should be put into
// the UI as configurable percentage value
// bufferZone determines the amount by which the area processed should exceed the actual image area.
// This is intended to avoid visible artifacts generated along the proscenium edge.
// Perhaps this is no longer needed now that entire view edges are culled at once, since that theoretically
// should eliminate visible artifacts.
// To the extent it is still useful, bufferZone should be put into the UI as configurable percentage value
const real bufferZone = 0.05;
// borderZone describes a blank border outside the proscenium, but
// still inside the image area. Only intended for exposing possible
// artifacts along or outside the proscenium edge during debugging.
// borderZone describes a blank border outside the proscenium, but still inside the image area.
// Only intended for exposing possible artifacts along or outside the proscenium edge during debugging.
const real borderZone = 0.0;
viewProscenium[0] = freestyle_viewport[2] * (borderZone - bufferZone);
viewProscenium[1] = freestyle_viewport[2] * (1.0f - borderZone + bufferZone);
@ -51,6 +54,6 @@ void GridHelpers::getDefaultViewProscenium(real viewProscenium[4]) {
viewProscenium[3] = freestyle_viewport[3] * (1.0f - borderZone + bufferZone);
}
GridHelpers::Transform::~Transform () {}
GridHelpers::Transform::~Transform ()
{
}

168
source/blender/freestyle/intern/geometry/GridHelpers.h
View File

@ -1,47 +1,55 @@
//
// Filename : GridHelpers.h
// Author(s) : Alexander Beels
// Purpose : Class to define a cell grid surrounding
// the projected image of a scene
// Date of creation : 2010-12-13
//
///////////////////////////////////////////////////////////////////////////////
/*
* ***** 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 __GRIDHELPERS_H__
#define __GRIDHELPERS_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 GRIDHELPERS_H
#define GRIDHELPERS_H
/** \file blender/freestyle/intern/geometry/GridHelpers.h
* \ingroup freestyle
* \brief Class to define a cell grid surrounding the projected image of a scene
* \author Alexander Beels
* \date 2010-12-13
*/
#include <vector>
#include "Polygon.h"
#include "../winged_edge/WEdge.h"
#include "FRS_freestyle.h"
#include "GeomUtils.h"
#include "Polygon.h"
#include "../winged_edge/WEdge.h"
namespace GridHelpers {
/*! Computes the distance from a point P to a segment AB */
template<class T>
T closestPointToSegment(const T& P, const T& A , const T& B, real& distance) {
T closestPointToSegment(const T& P, const T& A , const T& B, real& distance)
{
T AB, AP, BP;
AB = B - A;
AP = P - A;
@ -59,31 +67,32 @@ T closestPointToSegment(const T& P, const T& A , const T& B, real& distance) {
return B; // B is closest point
}
real b = c1 / c2;
T Pb, PPb;
Pb = A + b * AB;
PPb = P - Pb;
real b = c1 / c2;
T Pb, PPb;
Pb = A + b * AB;
PPb = P - Pb;
distance = PPb.norm();
distance = PPb.norm();
return Pb; // closest point lies on AB
}
inline Vec3r closestPointOnPolygon(const Vec3r& point, const Polygon3r& poly) {
inline Vec3r closestPointOnPolygon(const Vec3r& point, const Polygon3r& poly)
{
// First cast a ray from the point onto the polygon plane
// If the ray intersects the polygon, then the intersection point
// is the closest point on the polygon
real t, u, v;
if ( poly.rayIntersect(point, poly.getNormal(), t, u, v) ) {
if (poly.rayIntersect(point, poly.getNormal(), t, u, v)) {
return point + poly.getNormal() * t;
}
// Otherwise, get the nearest point on each edge, and take the closest
real distance;
Vec3r closest = closestPointToSegment(point, poly.getVertices()[2], poly.getVertices()[0], distance);
for ( unsigned i = 0; i < 2; ++i ) {
for (unsigned int i = 0; i < 2; ++i) {
real t;
Vec3r p = closestPointToSegment(point, poly.getVertices()[i], poly.getVertices()[i + 1], t);
if ( t < distance ) {
if (t < distance) {
distance = t;
closest = p;
}
@ -91,57 +100,63 @@ inline Vec3r closestPointOnPolygon(const Vec3r& point, const Polygon3r& poly) {
return closest;
}
inline real distancePointToPolygon(const Vec3r& point, const Polygon3r& poly) {
inline real distancePointToPolygon(const Vec3r& point, const Polygon3r& poly)
{
// First cast a ray from the point onto the polygon plane
// If the ray intersects the polygon, then the intersection point
// is the closest point on the polygon
real t, u, v;
if ( poly.rayIntersect(point, poly.getNormal(), t, u, v) ) {
return t > 0.0 ? t : -t;
if (poly.rayIntersect(point, poly.getNormal(), t, u, v)) {
return (t > 0.0) ? t : -t;
}
// Otherwise, get the nearest point on each edge, and take the closest
real distance = GeomUtils::distPointSegment(point, poly.getVertices()[2], poly.getVertices()[0]);
for ( unsigned i = 0; i < 2; ++i ) {
for (unsigned int i = 0; i < 2; ++i) {
real t = GeomUtils::distPointSegment(point, poly.getVertices()[i], poly.getVertices()[i + 1]);
if ( t < distance ) {
if (t < distance) {
distance = t;
}
}
return distance;
}
class Transform {
class Transform
{
public:
virtual ~Transform () =0;
virtual Vec3r operator()(const Vec3r& point) const =0;
virtual ~Transform () = 0;
virtual Vec3r operator()(const Vec3r& point) const = 0;
};
inline bool insideProscenium (const real proscenium[4], const Polygon3r& polygon) {
// N.B. The bounding box check is redundant for inserting occluders into
// cells, because the cell selection code in insertOccluders has already
// guaranteed that the bounding boxes will overlap.
inline bool insideProscenium (const real proscenium[4], const Polygon3r& polygon)
{
// N.B. The bounding box check is redundant for inserting occluders into cells, because the cell selection code
// in insertOccluders has already guaranteed that the bounding boxes will overlap.
// First check the viewport edges, since they are the easiest case
// Check if the bounding box is entirely outside the proscenium
Vec3r bbMin, bbMax;
polygon.getBBox(bbMin, bbMax);
if ( bbMax[0] < proscenium[0]
|| bbMin[0] > proscenium[1]
|| bbMax[1] < proscenium[2]
|| bbMin[1] > proscenium[3] ) {
if (bbMax[0] < proscenium[0] || bbMin[0] > proscenium[1] || bbMax[1] < proscenium[2] || bbMin[1] > proscenium[3]) {
return false;
}
Vec3r boxCenter(proscenium[0] + (proscenium[1] - proscenium[0]) / 2.0, proscenium[2] + (proscenium[3] - proscenium[2]) / 2.0, 0.0);
Vec3r boxHalfSize((proscenium[1] - proscenium[0]) / 2.0, (proscenium[3] - proscenium[2]) / 2.0, 1.0);
Vec3r triverts[3] = { Vec3r(polygon.getVertices()[0][0], polygon.getVertices()[0][1], 0.0), Vec3r(polygon.getVertices()[1][0], polygon.getVertices()[1][1], 0.0), Vec3r(polygon.getVertices()[2][0], polygon.getVertices()[2][1], 0.0) };
Vec3r boxCenter(proscenium[0] + (proscenium[1] - proscenium[0]) / 2.0,
proscenium[2] + (proscenium[3] - proscenium[2]) / 2.0, 0.0);
Vec3r boxHalfSize((proscenium[1] - proscenium[0]) / 2.0,
(proscenium[3] - proscenium[2]) / 2.0, 1.0);
Vec3r triverts[3] = {
Vec3r(polygon.getVertices()[0][0], polygon.getVertices()[0][1], 0.0),
Vec3r(polygon.getVertices()[1][0], polygon.getVertices()[1][1], 0.0),
Vec3r(polygon.getVertices()[2][0], polygon.getVertices()[2][1], 0.0)
};
return GeomUtils::overlapTriangleBox(boxCenter, boxHalfSize, triverts);
}
inline vector<Vec3r> enumerateVertices(const vector<WOEdge*>& fedges) {
inline vector<Vec3r> enumerateVertices(const vector<WOEdge*>& fedges)
{
vector<Vec3r> points;
// Iterate over vertices, storing projections in points
for(vector<WOEdge*>::const_iterator woe=fedges.begin(), woend=fedges.end(); woe!=woend; woe++) {
for (vector<WOEdge*>::const_iterator woe = fedges.begin(), woend = fedges.end(); woe != woend; woe++) {
points.push_back((*woe)->GetaVertex()->GetVertex());
}
@ -150,50 +165,51 @@ inline vector<Vec3r> enumerateVertices(const vector<WOEdge*>& fedges) {
void getDefaultViewProscenium(real viewProscenium[4]);
inline void expandProscenium (real proscenium[4], const Polygon3r& polygon) {
inline void expandProscenium (real proscenium[4], const Polygon3r& polygon)
{
Vec3r bbMin, bbMax;
polygon.getBBox(bbMin, bbMax);
const real epsilon = 1.0e-6;
if ( bbMin[0] <= proscenium[0] ) {
if (bbMin[0] <= proscenium[0]) {
proscenium[0] = bbMin[0] - epsilon;
}
if ( bbMin[1] <= proscenium[2] ) {
if (bbMin[1] <= proscenium[2]) {
proscenium[2] = bbMin[1] - epsilon;
}
if ( bbMax[0] >= proscenium[1] ) {
if (bbMax[0] >= proscenium[1]) {
proscenium[1] = bbMax[0] + epsilon;
}
if ( bbMax[1] >= proscenium[3] ) {
if (bbMax[1] >= proscenium[3]) {
proscenium[3] = bbMax[1] + epsilon;
}
}
inline void expandProscenium (real proscenium[4], const Vec3r& point) {
inline void expandProscenium (real proscenium[4], const Vec3r& point)
{
const real epsilon = 1.0e-6;
if ( point[0] <= proscenium[0] ) {
if (point[0] <= proscenium[0]) {
proscenium[0] = point[0] - epsilon;
}
if ( point[1] <= proscenium[2] ) {
if (point[1] <= proscenium[2]) {
proscenium[2] = point[1] - epsilon;
}
if ( point[0] >= proscenium[1] ) {
if (point[0] >= proscenium[1]) {
proscenium[1] = point[0] + epsilon;
}
if ( point[1] >= proscenium[3] ) {
if (point[1] >= proscenium[3]) {
proscenium[3] = point[1] + epsilon;
}
}
};
#endif // GRIDHELPERS_H
}; // GridHelpers namespace
#endif // __GRIDHELPERS_H__

74
source/blender/freestyle/intern/geometry/HashGrid.cpp
View File

@ -1,41 +1,53 @@
/*
* ***** 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/geometry/HashGrid.cpp
* \ingroup freestyle
* \brief Class to define a cell grid surrounding the bounding box of the scene
* \author Stephane Grabli
* \date 30/07/2002
*/
#include "HashGrid.h"
void HashGrid::clear()
{
if(!_cells.empty()) {
for(GridHashTable::iterator it = _cells.begin();
it !=_cells.end();
it++) {
Cell* cell = (*it).second;
delete cell;
}
_cells.clear();
}
if (!_cells.empty()) {
for (GridHashTable::iterator it = _cells.begin(); it !=_cells.end(); it++) {
Cell* cell = (*it).second;
delete cell;
}
_cells.clear();
}
Grid::clear();
Grid::clear();
}
void HashGrid::configure(const Vec3r& orig, const Vec3r& size, unsigned nb) {
Grid::configure(orig, size, nb);
void HashGrid::configure(const Vec3r& orig, const Vec3r& size, unsigned nb)
{
Grid::configure(orig, size, nb);
}

183
source/blender/freestyle/intern/geometry/HashGrid.h
View File

@ -1,109 +1,116 @@
//
// Filename : HashGrid.h
// Author(s) : Stephane Grabli
// Purpose : Class to define a cell grid surrounding the
// bounding box of the scene
// Date of creation : 30/07/2002
//
///////////////////////////////////////////////////////////////////////////////
/*
* ***** 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 __HASHGRID_H__
#define __HASHGRID_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/geometry/HashGrid.h
* \ingroup freestyle
* \brief Class to define a cell grid surrounding the bounding box of the scene
* \author Stephane Grabli
* \date 30/07/2002
*/
#ifndef HASHGRID_H
# define HASHGRID_H
//# if defined(__GNUC__) && (__GNUC__ >= 3)
#if 0
# if defined(__GNUC__) && (__GNUC__ >= 3)
// hash_map is not part of the C++ standard anymore;
// hash_map.h has been kept though for backward compatibility
//# include <hash_map.h>
//# else
//# include <hash_map>
//# endif
# include <hash_map.h>
# else
# include <hash_map>
# endif
#endif
#include <map>
#include "Grid.h"
# include "Grid.h"
# include <map>
/*! Defines a hash table used for searching the Cells */
struct GridHasher{
struct GridHasher
{
#define _MUL 950706376UL
#define _MOD 2147483647UL
inline size_t operator() (const Vec3u& p) const
{
size_t res = ((unsigned long) (p[0] * _MUL)) % _MOD;
res = ((res + (unsigned long) (p[1]) * _MUL)) % _MOD;
return ((res +(unsigned long) (p[2]) * _MUL)) % _MOD;
}
inline size_t operator() (const Vec3u& p) const
{
size_t res = ((unsigned long) (p[0] * _MUL)) % _MOD;
res = ((res + (unsigned long) (p[1]) * _MUL)) % _MOD;
return ((res +(unsigned long) (p[2]) * _MUL)) % _MOD;
}
#undef _MUL
#undef _MOD
};
/*! Class to define a regular grid used for ray
casting computations */
/*! Class to define a regular grid used for ray casting computations */
class LIB_GEOMETRY_EXPORT HashGrid : public Grid
{
public:
public:
typedef map<Vec3u, Cell*> GridHashTable;
typedef map<Vec3u, Cell*> GridHashTable;
HashGrid() : Grid() {}
HashGrid() : Grid() {}
virtual ~HashGrid() {
clear();
}
virtual ~HashGrid()
{
clear();
}
/*! clears the grid
* Deletes all the cells, clears the hashtable,
* resets size, size of cell, number of cells.
*/
virtual void clear();
/*! clears the grid
* Deletes all the cells, clears the hashtable, resets size, size of cell, number of cells.
*/
virtual void clear();
/*! Sets the different parameters of the grid
* orig
* The grid origin
* size
* The grid's dimensions
* nb
* The number of cells of the grid
*/
virtual void configure(const Vec3r& orig, const Vec3r& size, unsigned nb);
/*! returns the cell whose coordinates
* are pased as argument
*/
virtual Cell* getCell(const Vec3u& p) {
Cell* found_cell = NULL;
GridHashTable::const_iterator found = _cells.find(p);
if (found != _cells.end())
found_cell = (*found).second;
return found_cell;
}
/*! Fills the case p with the cell iCell */
virtual void fillCell(const Vec3u& p, Cell& cell) {
_cells[p] = &cell;
}
/*! Sets the different parameters of the grid
* orig
* The grid origin
* size
* The grid's dimensions
* nb
* The number of cells of the grid
*/
virtual void configure(const Vec3r& orig, const Vec3r& size, unsigned nb);
/*! returns the cell whose coordinates are pased as argument */
virtual Cell* getCell(const Vec3u& p)
{
Cell* found_cell = NULL;
GridHashTable::const_iterator found = _cells.find(p);
if (found != _cells.end())
found_cell = (*found).second;
return found_cell;
}
/*! Fills the case p with the cell iCell */
virtual void fillCell(const Vec3u& p, Cell& cell)
{
_cells[p] = &cell;
}
protected:
GridHashTable _cells;
GridHashTable _cells;
};
#endif // HASHGRID_H
#endif // __HASHGRID_H__

395
source/blender/freestyle/intern/geometry/Noise.cpp
View File

@ -1,264 +1,285 @@
/*
* ***** 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/geometry/Noise.cpp
* \ingroup freestyle
* \brief Class to define Perlin noise
* \author Emmanuel Turquin
* \date 12/01/2004
*/
#include "Noise.h"
# include <stdlib.h>
# include <stdio.h>
# include <math.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define MINX -1000000
#define MINY MINX
#define MINZ MINX
#define SCURVE(a) ((a)*(a)*(3.0-2.0*(a)))
#define REALSCALE ( 2.0 / 65536.0 )
#define NREALSCALE ( 2.0 / 4096.0 )
#define HASH3D(a,b,c) hashTable[hashTable[hashTable[(a) & 0xfff] ^ ((b) & 0xfff)] ^ ((c) & 0xfff)]
#define HASH(a,b,c) (xtab[(xtab[(xtab[(a) & 0xff] ^ (b)) & 0xff] ^ (c)) & 0xff] & 0xff)
#define INCRSUM(m,s,x,y,z) ((s)*(RTable[m]*0.5 \
+ RTable[m+1]*(x) \
+ RTable[m+2]*(y) \
+ RTable[m+3]*(z)))
#define MAXSIZE 500
#define nrand() ((float)rand()/(float)RAND_MAX)
#define seednrand(x) srand(x*RAND_MAX)
#include "Noise.h"
#define MINX -1000000
#define MINY MINX
#define MINZ MINX
#define SCURVE(a) ((a) * (a) * (3.0 - 2.0 * (a)))
#define REALSCALE (2.0 / 65536.0)
#define NREALSCALE (2.0 / 4096.0)
#define HASH3D(a, b, c) hashTable[hashTable[hashTable[(a) & 0xfff] ^ ((b) & 0xfff)] ^ ((c) & 0xfff)]
#define HASH(a, b, c) (xtab[(xtab[(xtab[(a) & 0xff] ^ (b)) & 0xff] ^ (c)) & 0xff] & 0xff)
#define INCRSUM(m, s, x, y, z) \
((s) * (RTable[m] * 0.5 + RTable[m + 1] * (x) + RTable[m + 2] * (y) + RTable[m + 3] * (z)))
#define MAXSIZE 500
#if 0 // XXX Unused
#define NRAND() ((float)rand() / (float)RAND_MAX)
#endif
#define SEEDNRAND(x) (srand(x * RAND_MAX))
#define BM 0xff
#define N 0x1000
#define NP 12 /* 2^N */
#define N 0x1000
#define NP 12 /* 2^N */
#define NM 0xfff
#define s_curve(t) ( t * t * (3. - 2. * t) )
#define LERP(t, a, b) ((a) + (t) * ((b) - (a)))
#define lerp(t, a, b) ( a + t * (b - a) )
#define setup(i,b0,b1,r0,r1)\
t = i + N;\
b0 = ((int)t) & BM;\
b1 = (b0+1) & BM;\
r0 = t - (int)t;\
r1 = r0 - 1.;
#define SETUP(i, b0, b1, r0, r1) \
{ \
(t) = (i) + (N); \
(b0) = ((int)(t)) & BM; \
(b1) = ((b0) + 1) & BM; \
(r0) = (t) - (int)(t); \
(r1) = (r0) - 1.0; \
} (void)0
static void normalize2(float v[2])
{
float s;
float s;
s = sqrt(v[0] * v[0] + v[1] * v[1]);
v[0] = v[0] / s;
v[1] = v[1] / s;
s = sqrt(v[0] * v[0] + v[1] * v[1]);
v[0] = v[0] / s;
v[1] = v[1] / s;
}
static void normalize3(float v[3])
{
float s;
float s;
s = sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
v[0] = v[0] / s;
v[1] = v[1] / s;
v[2] = v[2] / s;
s = sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
v[0] = v[0] / s;
v[1] = v[1] / s;
v[2] = v[2] / s;
}
float Noise::turbulence1(float arg, float freq, float amp, unsigned oct)
{
float t;
float vec;
for (t = 0; oct > 0 && freq > 0; freq *= 2, amp /= 2, --oct)
{
vec = freq * arg;
t += smoothNoise1(vec) * amp;
}
return t;
float t;
float vec;
for (t = 0; oct > 0 && freq > 0; freq *= 2, amp /= 2, --oct) {
vec = freq * arg;
t += smoothNoise1(vec) * amp;
}
return t;
}
float Noise::turbulence2(Vec2f& v, float freq, float amp, unsigned oct)
{
float t;
Vec2f vec;
for (t = 0; oct > 0 && freq > 0; freq *= 2, amp /= 2, --oct)
{
vec.x() = freq * v.x();
vec.y() = freq * v.y();
t += smoothNoise2(vec) * amp;
}
return t;
float t;
Vec2f vec;
for (t = 0; oct > 0 && freq > 0; freq *= 2, amp /= 2, --oct) {
vec.x() = freq * v.x();
vec.y() = freq * v.y();
t += smoothNoise2(vec) * amp;
}
return t;
}
float Noise::turbulence3(Vec3f& v, float freq, float amp, unsigned oct)
{
float t;
Vec3f vec;
for (t = 0; oct > 0 && freq > 0; freq *= 2, amp /= 2, --oct)
{
vec.x() = freq * v.x();
vec.y() = freq * v.y();
vec.z() = freq * v.z();
t += smoothNoise3(vec) * amp;
}
return t;
float t;
Vec3f vec;
for (t = 0; oct > 0 && freq > 0; freq *= 2, amp /= 2, --oct) {
vec.x() = freq * v.x();
vec.y() = freq * v.y();
vec.z() = freq * v.z();
t += smoothNoise3(vec) * amp;
}
return t;
}
// Noise functions over 1, 2, and 3 dimensions
float Noise::smoothNoise1(float arg)
{
int bx0, bx1;
float rx0, rx1, sx, t, u, v, vec;
int bx0, bx1;
float rx0, rx1, sx, t, u, v, vec;
vec = arg;
setup(vec, bx0,bx1, rx0,rx1);
vec = arg;
SETUP(vec, bx0, bx1, rx0, rx1);
sx = s_curve(rx0);
sx = SCURVE(rx0);
u = rx0 * g1[ p[ bx0 ] ];
v = rx1 * g1[ p[ bx1 ] ];
u = rx0 * g1[p[bx0]];
v = rx1 * g1[p[bx1]];
return lerp(sx, u, v);
return LERP(sx, u, v);
}
float Noise::smoothNoise2(Vec2f& vec)
{
int bx0, bx1, by0, by1, b00, b10, b01, b11;
float rx0, rx1, ry0, ry1, *q, sx, sy, a, b, t, u, v;
register int i, j;
int bx0, bx1, by0, by1, b00, b10, b01, b11;
float rx0, rx1, ry0, ry1, *q, sx, sy, a, b, t, u, v;
register int i, j;
setup(vec.x(), bx0,bx1, rx0,rx1);
setup(vec.y(), by0,by1, ry0,ry1);
SETUP(vec.x(), bx0, bx1, rx0, rx1);
SETUP(vec.y(), by0, by1, ry0, ry1);
i = p[ bx0 ];
j = p[ bx1 ];
i = p[bx0];
j = p[bx1];
b00 = p[ i + by0 ];
b10 = p[ j + by0 ];
b01 = p[ i + by1 ];
b11 = p[ j + by1 ];
b00 = p[i + by0];
b10 = p[j + by0];
b01 = p[i + by1];
b11 = p[j + by1];
sx = s_curve(rx0);
sy = s_curve(ry0);
sx = SCURVE(rx0);
sy = SCURVE(ry0);
#define at2(rx,ry) ( rx * q[0] + ry * q[1] )
#define AT2(rx, ry) ((rx) * q[0] + (ry) * q[1])
q = g2[ b00 ] ; u = at2(rx0,ry0);
q = g2[ b10 ] ; v = at2(rx1,ry0);
a = lerp(sx, u, v);
q = g2[b00];
u = AT2(rx0, ry0);
q = g2[b10];
v = AT2(rx1, ry0);
a = LERP(sx, u, v);
q = g2[ b01 ] ; u = at2(rx0,ry1);
q = g2[ b11 ] ; v = at2(rx1,ry1);
b = lerp(sx, u, v);
q = g2[b01];
u = AT2(rx0, ry1);
q = g2[b11];
v = AT2(rx1, ry1);
b = LERP(sx, u, v);
return lerp(sy, a, b);
#undef AT2
return LERP(sy, a, b);
}
float Noise::smoothNoise3(Vec3f& vec)
{
int bx0, bx1, by0, by1, bz0, bz1, b00, b10, b01, b11;
float rx0, rx1, ry0, ry1, rz0, rz1, *q, sy, sz, a, b, c, d, t, u, v;
register int i, j;
int bx0, bx1, by0, by1, bz0, bz1, b00, b10, b01, b11;
float rx0, rx1, ry0, ry1, rz0, rz1, *q, sy, sz, a, b, c, d, t, u, v;
register int i, j;
setup(vec.x(), bx0,bx1, rx0,rx1);
setup(vec.y(), by0,by1, ry0,ry1);
setup(vec.z(), bz0,bz1, rz0,rz1);
SETUP(vec.x(), bx0, bx1, rx0, rx1);
SETUP(vec.y(), by0, by1, ry0, ry1);
SETUP(vec.z(), bz0, bz1, rz0, rz1);
i = p[ bx0 ];
j = p[ bx1 ];
i = p[bx0];
j = p[bx1];
b00 = p[ i + by0 ];
b10 = p[ j + by0 ];
b01 = p[ i + by1 ];
b11 = p[ j + by1 ];
b00 = p[i + by0];
b10 = p[j + by0];
b01 = p[i + by1];
b11 = p[j + by1];
t = s_curve(rx0);
sy = s_curve(ry0);
sz = s_curve(rz0);
t = SCURVE(rx0);
sy = SCURVE(ry0);
sz = SCURVE(rz0);
#define at3(rx,ry,rz) ( rx * q[0] + ry * q[1] + rz * q[2] )
#define AT3(rx, ry, rz) ((rx) * q[0] + (ry) * q[1] + (rz) * q[2])
q = g3[ b00 + bz0 ] ;
u = at3(rx0,ry0,rz0);
q = g3[ b10 + bz0 ] ;
v = at3(rx1,ry0,rz0);
a = lerp(t, u, v);
q = g3[b00 + bz0];
u = AT3(rx0, ry0, rz0);
q = g3[b10 + bz0];
v = AT3(rx1, ry0, rz0);
a = LERP(t, u, v);
q = g3[ b01 + bz0 ] ;
u = at3(rx0,ry1,rz0);
q = g3[ b11 + bz0 ] ;
v = at3(rx1,ry1,rz0);
b = lerp(t, u, v);
q = g3[b01 + bz0];
u = AT3(rx0, ry1, rz0);
q = g3[b11 + bz0];
v = AT3(rx1, ry1, rz0);
b = LERP(t, u, v);
c = lerp(sy, a, b);
c = LERP(sy, a, b);
q = g3[ b00 + bz1 ] ;
u = at3(rx0,ry0,rz1);
q = g3[ b10 + bz1 ] ;
v = at3(rx1,ry0,rz1);
a = lerp(t, u, v);
q = g3[b00 + bz1];
u = AT3(rx0, ry0, rz1);
q = g3[b10 + bz1];
v = AT3(rx1, ry0, rz1);
a = LERP(t, u, v);
q = g3[ b01 + bz1 ] ;
u = at3(rx0,ry1,rz1);
q = g3[ b11 + bz1 ] ;
v = at3(rx1,ry1,rz1);
b = lerp(t, u, v);
q = g3[b01 + bz1];
u = AT3(rx0, ry1, rz1);
q = g3[b11 + bz1];
v = AT3(rx1, ry1, rz1);
b = LERP(t, u, v);
d = lerp(sy, a, b);
d = LERP(sy, a, b);
return lerp(sz, c, d);
#undef AT3
return LERP(sz, c, d);
}
Noise::Noise(long seed)
{
int i, j, k;
seednrand((seed < 0) ? time(NULL) : seed);
for (i = 0 ; i < _Noise_B_ ; i++)
{
p[i] = i;
int i, j, k;
g1[i] = (float)((rand() % (_Noise_B_ + _Noise_B_)) - _Noise_B_) / _Noise_B_;
SEEDNRAND((seed < 0) ? time(NULL) : seed);
for (i = 0 ; i < _NOISE_B ; i++) {
p[i] = i;
g1[i] = (float)((rand() % (_NOISE_B + _NOISE_B)) - _NOISE_B) / _NOISE_B;
for (j = 0 ; j < 2 ; j++)
g2[i][j] = (float)((rand() % (_Noise_B_ + _Noise_B_)) - _Noise_B_) / _Noise_B_;
normalize2(g2[i]);
for (j = 0 ; j < 2 ; j++)
g2[i][j] = (float)((rand() % (_NOISE_B + _NOISE_B)) - _NOISE_B) / _NOISE_B;
normalize2(g2[i]);
for (j = 0 ; j < 3 ; j++)
g3[i][j] = (float)((rand() % (_Noise_B_ + _Noise_B_)) - _Noise_B_) / _Noise_B_;
normalize3(g3[i]);
}
for (j = 0 ; j < 3 ; j++)
g3[i][j] = (float)((rand() % (_NOISE_B + _NOISE_B)) - _NOISE_B) / _NOISE_B;
normalize3(g3[i]);
}
while (--i)
{
k = p[i];
p[i] = p[j = rand() % _Noise_B_];
p[j] = k;
}
while (--i) {
k = p[i];
p[i] = p[j = rand() % _NOISE_B];
p[j] = k;
}
for (i = 0 ; i < _Noise_B_ + 2 ; i++)
{
p[_Noise_B_ + i] = p[i];
g1[_Noise_B_ + i] = g1[i];
for (j = 0 ; j < 2 ; j++)
g2[_Noise_B_ + i][j] = g2[i][j];
for (j = 0 ; j < 3 ; j++)
g3[_Noise_B_ + i][j] = g3[i][j];
}
for (i = 0 ; i < _NOISE_B + 2 ; i++) {
p[_NOISE_B + i] = p[i];
g1[_NOISE_B + i] = g1[i];
for (j = 0 ; j < 2 ; j++)
g2[_NOISE_B + i][j] = g2[i][j];
for (j = 0 ; j < 3 ; j++)
g3[_NOISE_B + i][j] = g3[i][j];
}
}

118
source/blender/freestyle/intern/geometry/Noise.h
View File

@ -1,40 +1,45 @@
//
// Filename : Noise.h
// Author(s) : Emmanuel Turquin
// Purpose : Class to define Perlin noise
// Date of creation : 12/01/2004
//
///////////////////////////////////////////////////////////////////////////////
/*
* ***** 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 __NOISE_H__
#define __NOISE_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/geometry/Noise.h
* \ingroup freestyle
* \brief Class to define Perlin noise
* \author Emmanuel Turquin
* \date 12/01/2004
*/
#ifndef NOISE_H
# define NOISE_H
#include "Geom.h"
#include "../system/FreestyleConfig.h"
# include "../system/FreestyleConfig.h"
# include "Geom.h"
#define _Noise_B_ 0x100
#define _NOISE_B 0x100
using namespace Geometry;
using namespace std;
@ -42,36 +47,37 @@ using namespace std;
/*! Class to provide Perlin Noise functionalities */
class LIB_GEOMETRY_EXPORT Noise
{
public:
public:
/*! Builds a Noise object */
Noise(long seed = -1);
/*! Builds a Noise object */
Noise(long seed = -1);
/*! Destructor */
~Noise() {}
/*! Destructor */
~Noise() {}
/*! Returns a noise value for a 1D element */
float turbulence1(float arg, float freq, float amp, unsigned oct = 4);
/*! Returns a noise value for a 1D element */
float turbulence1(float arg, float freq, float amp, unsigned oct = 4);
/*! Returns a noise value for a 2D element */
float turbulence2(Vec2f& v, float freq, float amp, unsigned oct = 4);
/*! Returns a noise value for a 2D element */
float turbulence2(Vec2f& v, float freq, float amp, unsigned oct = 4);
/*! Returns a noise value for a 3D element */
float turbulence3(Vec3f& v, float freq, float amp, unsigned oct = 4);
/*! Returns a noise value for a 3D element */
float turbulence3(Vec3f& v, float freq, float amp, unsigned oct = 4);
/*! Returns a smooth noise value for a 1D element */
float smoothNoise1(float arg);
/*! Returns a smooth noise value for a 2D element */
float smoothNoise2(Vec2f& vec);
/*! Returns a smooth noise value for a 3D element */
float smoothNoise3(Vec3f& vec);
/*! Returns a smooth noise value for a 1D element */
float smoothNoise1(float arg);
private:
/*! Returns a smooth noise value for a 2D element */
float smoothNoise2(Vec2f& vec);
int p[ _Noise_B_ + _Noise_B_ + 2];
float g3[ _Noise_B_ + _Noise_B_ + 2][3];
float g2[ _Noise_B_ + _Noise_B_ + 2][2];
float g1[ _Noise_B_ + _Noise_B_ + 2];
int start;
/*! Returns a smooth noise value for a 3D element */
float smoothNoise3(Vec3f& vec);
private:
int p[_NOISE_B + _NOISE_B + 2];
float g3[_NOISE_B + _NOISE_B + 2][3];
float g2[_NOISE_B + _NOISE_B + 2][2];
float g1[_NOISE_B + _NOISE_B + 2];
int start;
};
#endif // NOISE_H
#endif // __NOISE_H__

339
source/blender/freestyle/intern/geometry/Polygon.h
View File

@ -1,38 +1,44 @@
//
// Filename : Polygon.h
// Author(s) : Stephane Grabli
// Purpose : Class to define a polygon
// Date of creation : 30/07/2002
//
///////////////////////////////////////////////////////////////////////////////
/*
* ***** 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 __POLYGON_H__
#define __POLYGON_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/geometry/Polygon.h
* \ingroup freestyle
* \brief Class to define a polygon
* \author Stephane Grabli
* \date 30/07/2002
*/
#ifndef POLYGON_H
# define POLYGON_H
#include <vector>
# include <vector>
# include "Geom.h"
# include "GeomUtils.h"
#include "Geom.h"
#include "GeomUtils.h"
using namespace std;
@ -41,129 +47,129 @@ namespace Geometry {
template <class Point>
class Polygon
{
public:
public:
inline Polygon()
{
_id = 0;
userdata = 0;
userdata2 = 0;
}
inline Polygon() {
_id = 0;
userdata = 0;
userdata2 = 0;
}
inline Polygon(const vector<Point>& vertices)
{
_vertices = vertices;
computeBBox();
_id = 0;
userdata = 0;
userdata2 = 0;
}
inline Polygon(const vector<Point>& vertices) {
_vertices = vertices;
computeBBox();
_id = 0;
userdata = 0;
userdata2 = 0;
}
inline Polygon(const Polygon<Point>& poly)
{
Point p;
for (typename vector<Point>::const_iterator it = poly.getVertices().begin();
it != poly.getVertices().end();
it++)
{
p = *it;
_vertices.push_back(p);
}
inline Polygon(const Polygon<Point>& poly) {
Point p;
for(typename vector<Point>::const_iterator it = poly.getVertices().begin();
it != poly.getVertices().end();
it++) {
p = *it;
_vertices.push_back(p);
}
_id = poly.getId();
poly.getBBox(_min, _max);
userdata = 0;
userdata2 = 0;
}
_id = poly.getId();
poly.getBBox(_min, _max);
userdata = 0;
userdata2 = 0;
}
virtual ~Polygon() {}
virtual ~Polygon() {}
//
// Accessors
//
/////////////////////////////////////////////////////////////////////////////
//
// Accessors
//
/////////////////////////////////////////////////////////////////////////////
inline const vector<Point>& getVertices() const
{
return _vertices;
}
inline const vector<Point>& getVertices() const {
return _vertices;
}
inline void getBBox(Point& min, Point& max) const
{
min = _min;
max = _max;
}
inline void getBBox(Point& min, Point& max) const {
min = _min;
max = _max;
}
inline Point& getBBoxCenter()
{
Point result;
result = (_min + _max) / 2;
return result;
}
inline Point& getBBoxCenter()
{
Point result;
result = (_min + _max) / 2;
return result;
}
inline Point& getCenter()
{
Point result;
for (typename vector<Point>::iterator it = _vertices.begin(); it != _vertices.end(); it++)
result += *it;
result /= _vertices.size();
return result;
}
inline Point& getCenter() {
Point result;
for (typename vector<Point>::iterator it = _vertices.begin();
it != _vertices.end();
it++)
result += *it;
result /= _vertices.size();
return result;
}
inline unsigned getId() const
{
return _id;
}
inline unsigned getId() const {
return _id;
}
//
// Modifiers
//
/////////////////////////////////////////////////////////////////////////////
inline void setVertices(const vector<Point>& vertices)
{
_vertices.clear();
Point p;
for (typename vector<Point>::const_iterator it = vertices.begin(); it != vertices.end(); it++) {
p = *it;
_vertices.push_back(p);
}
computeBBox();
}
//
// Modifiers
//
/////////////////////////////////////////////////////////////////////////////
inline void setId(unsigned id)
{
_id = id;
}
inline void setVertices(const vector<Point>& vertices) {
_vertices.clear();
Point p;
for (typename vector<Point>::const_iterator it = vertices.begin();
it != vertices.end();
it++) {
p = *it;
_vertices.push_back(p);
}
computeBBox();
}
//
// Other methods
//
/////////////////////////////////////////////////////////////////////////////
inline void computeBBox()
{
if (_vertices.empty())
return;
inline void setId(unsigned id) {
_id = id;
}
_max = _vertices[0];
_min = _vertices[0];
//
// Other methods
//
/////////////////////////////////////////////////////////////////////////////
for (typename vector<Point>::iterator it = _vertices.begin(); it != _vertices.end(); it++) {
for (unsigned int i = 0; i < Point::dim(); i++) {
if ((*it)[i] > _max[i])
_max[i] = (*it)[i];
if ((*it)[i] < _min[i])
_min[i] = (*it)[i];
}
}
}
inline void computeBBox() {
if(_vertices.empty())
return;
_max = _vertices[0];
_min = _vertices[0];
// FIXME Is it possible to get rid of userdatas ?
void* userdata;
void* userdata2; // Used during ray casting
for(typename vector<Point>::iterator it = _vertices.begin();
it != _vertices.end();
it++) {
for(unsigned i = 0; i < Point::dim(); i++) {
if((*it)[i] > _max[i])
_max[i] = (*it)[i];
if((*it)[i] < _min[i])
_min[i] = (*it)[i];
}
}
}
// FIXME Is it possible to get rid of userdatas ?
void* userdata;
void* userdata2; // Used during ray casting
protected:
vector<Point> _vertices;
Point _min;
Point _max;
unsigned _id;
protected:
vector<Point> _vertices;
Point _min;
Point _max;
unsigned _id;
};
@ -171,44 +177,45 @@ class Polygon
// Polygon3r class
//
///////////////////////////////////////////////////////////////////////////////
class Polygon3r : public Polygon<Vec3r>
{
public:
inline Polygon3r() : Polygon<Vec3r>() {}
public:
inline Polygon3r() : Polygon<Vec3r>() {}
inline Polygon3r(const vector<Vec3r>& vertices,
const Vec3r& normal) : Polygon<Vec3r>(vertices) {
setNormal(normal);
}
inline Polygon3r(const vector<Vec3r>& vertices, const Vec3r& normal) : Polygon<Vec3r>(vertices)
{
setNormal(normal);
}
inline Polygon3r(const Polygon3r& poly) : Polygon<Vec3r>(poly), _normal(poly._normal) {}
virtual ~Polygon3r() {}
inline Polygon3r(const Polygon3r& poly) : Polygon<Vec3r>(poly), _normal(poly._normal) {}
void setNormal(const Vec3r& normal) {
_normal = normal;
}
virtual ~Polygon3r() {}
inline Vec3r getNormal() const {
return _normal;
}
void setNormal(const Vec3r& normal)
{
_normal = normal;
}
/*! Check whether the Polygon intersects with the ray or not */
inline bool rayIntersect(const Vec3r& orig, const Vec3r& dir,
real& t, real& u, real& v, real epsilon = M_EPSILON) const {
// if (_vertices.size() < 3)
// return false;
return GeomUtils::intersectRayTriangle(orig, dir,
_vertices[0], _vertices[1], _vertices[2],
t, u, v, epsilon);
}
inline Vec3r getNormal() const
{
return _normal;
}
private:
/*! Check whether the Polygon intersects with the ray or not */
inline bool rayIntersect(const Vec3r& orig, const Vec3r& dir, real& t, real& u, real& v,
real epsilon = M_EPSILON) const
{
#if 0
if (_vertices.size() < 3)
return false;
#endif
return GeomUtils::intersectRayTriangle(orig, dir, _vertices[0], _vertices[1], _vertices[2], t, u, v, epsilon);
}
Vec3r _normal;
private:
Vec3r _normal;
};
} // end of namespace Geometry
#endif // POLYGON_H
#endif // __POLYGON_H__

547
source/blender/freestyle/intern/geometry/SweepLine.h
View File

@ -1,198 +1,202 @@
//
// Filename : SweepLine.h
// Author(s) : Stephane Grabli
// Purpose : Class to define a Sweep Line
// Date of creation : 29/08/2002
//
///////////////////////////////////////////////////////////////////////////////
/*
* ***** 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 __SWEEPLINE_H__
#define __SWEEPLINE_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/geometry/SweepLine.h
* \ingroup freestyle
* \brief Class to define a Sweep Line
* \author Stephane Grabli
* \date 29/08/2002
*/
#ifndef SWEEPLINE_H
# define SWEEPLINE_H
# include <list>
# include <vector>
#include <list>
#include <vector>
/*! Class to define the intersection berween two segments*/
template<class Edge>
class Intersection
{
public:
template<class EdgeClass>
Intersection(EdgeClass* eA, real ta, EdgeClass* eB, real tb)
{
EdgeA = eA;
EdgeB = eB;
tA = ta;
tB = tb;
userdata = 0;
}
template<class EdgeClass>
Intersection(EdgeClass* eA, real ta, EdgeClass* eB, real tb)
{
EdgeA = eA;
EdgeB = eB;
tA = ta;
tB = tb;
userdata = 0;
}
Intersection(const Intersection& iBrother)
{
EdgeA = iBrother.EdgeA;
EdgeB = iBrother.EdgeB;
tA = iBrother.tA;
tB = iBrother.tB;
userdata = 0;
}
Intersection(const Intersection& iBrother)
{
EdgeA = iBrother.EdgeA;
EdgeB = iBrother.EdgeB;
tA = iBrother.tA;
tB = iBrother.tB;
userdata = 0;
}
/*! returns the parameter giving the
* intersection, for the edge iEdge
*/
real getParameter(Edge *iEdge)
{
if(iEdge == EdgeA)
return tA;
if(iEdge == EdgeB)
return tB;
return 0;
}
/*! returns the parameter giving the intersection, for the edge iEdge */
real getParameter(Edge *iEdge)
{
if (iEdge == EdgeA)
return tA;
if (iEdge == EdgeB)
return tB;
return 0;
}
public:
void * userdata; // FIXME
void * userdata; // FIXME
Edge *EdgeA; // first segment
Edge *EdgeB; // second segment
real tA; // parameter defining the intersection point with respect to the segment EdgeA.
real tB; // parameter defining the intersection point with respect to the segment EdgeB.
Edge *EdgeA; // first segment
Edge *EdgeB; // second segment
real tA; // parameter defining the intersection point with respect to the segment EdgeA.
real tB; // parameter defining the intersection point with respect to the segment EdgeB.
};
template<class T, class Point>
class Segment
{
public:
Segment()
{
}
Segment(T& s, const Point& iA, const Point& iB)
{
_edge = s;
if(iA < iB)
{
A = iA;
B = iB;
_order = true;
}
else
{
A = iB;
B = iA;
_order = false;
}
}
public:
Segment()
{
}
Segment(Segment<T,Point>& iBrother)
{
_edge = iBrother.edge();
A = iBrother.A;
B = iBrother.B;
_Intersections = iBrother._Intersections;
_order = iBrother._order;
}
Segment(T& s, const Point& iA, const Point& iB)
{
_edge = s;
if (iA < iB) {
A = iA;
B = iB;
_order = true;
}
else {
A = iB;
B = iA;
_order = false;
}
}
Segment(const Segment<T,Point>& iBrother)
{
_edge = iBrother._edge;
A = iBrother.A;
B = iBrother.B;
_Intersections = iBrother._Intersections;
_order = iBrother._order;
}
Segment(Segment<T,Point>& iBrother)
{
_edge = iBrother.edge();
A = iBrother.A;
B = iBrother.B;
_Intersections = iBrother._Intersections;
_order = iBrother._order;
}
~Segment() {
_Intersections.clear();
}
Segment(const Segment<T,Point>& iBrother)
{
_edge = iBrother._edge;
A = iBrother.A;
B = iBrother.B;
_Intersections = iBrother._Intersections;
_order = iBrother._order;
}
inline Point operator[](const unsigned short int& i) const
{
return i%2==0 ? A : B;
}
~Segment()
{
_Intersections.clear();
}
inline bool operator==(const Segment<T,Point>& iBrother)
{
if(_edge == iBrother._edge)
return true;
inline Point operator[](const unsigned short int& i) const
{
return (i % 2 == 0) ? A : B;
}
return false;
}
/* Adds an intersection for this segment */
inline void AddIntersection(Intersection<Segment<T,Point> > *i) {_Intersections.push_back(i);}
inline bool operator==(const Segment<T,Point>& iBrother)
{
if (_edge == iBrother._edge)
return true;
return false;
}
/*! Checks for a common vertex with another edge */
inline bool CommonVertex(const Segment<T,Point>& S, Point& CP)
{
if((A == S[0]) || (A == S[1]))
{
CP = A;
return true;
}
if((B == S[0]) || (B == S[1]))
{
CP = B;
return true;
}
/* Adds an intersection for this segment */
inline void AddIntersection(Intersection<Segment<T,Point> > *i)
{
_Intersections.push_back(i);
}
return false;
}
/*! Checks for a common vertex with another edge */
inline bool CommonVertex(const Segment<T,Point>& S, Point& CP)
{
if ((A == S[0]) || (A == S[1])) {
CP = A;
return true;
}
if ((B == S[0]) || (B == S[1])) {
CP = B;
return true;
}
return false;
}
inline vector<Intersection<Segment<T,Point> >*>& intersections() {return _Intersections;}
inline bool order() {return _order;}
inline T& edge() {return _edge;}
inline vector<Intersection<Segment<T,Point> >*>& intersections()
{
return _Intersections;
}
private:
T _edge;
Point A;
Point B;
std::vector<Intersection<Segment<T,Point> >*> _Intersections; // list of intersections parameters
bool _order; // true if A and B are in the same order than _edge.A and _edge.B. false otherwise.
inline bool order()
{
return _order;
}
inline T& edge()
{
return _edge;
}
private:
T _edge;
Point A;
Point B;
std::vector<Intersection<Segment<T,Point> >*> _Intersections; // list of intersections parameters
bool _order; // true if A and B are in the same order than _edge.A and _edge.B. false otherwise.
};
/*! defines a binary function that can be overload
* by the user to specify at each condition
* the intersection between 2 edges must be computed
/*! defines a binary function that can be overload by the user to specify at each condition the intersection
* between 2 edges must be computed
*/
template<class T1, class T2>
struct binary_rule
struct binary_rule
{
binary_rule() {}
template<class T3,class T4>
binary_rule(const binary_rule<T3,T4>& brother) {}
virtual ~binary_rule() {}
binary_rule() {}
template<class T3,class T4> binary_rule(const binary_rule<T3,T4>& brother) {}
virtual ~binary_rule() {}
virtual bool operator()(T1&, T2&)
{
return true;
}
virtual bool operator()(T1&, T2&)
{
return true;
}
};
@ -200,126 +204,121 @@ template<class T,class Point>
class SweepLine
{
public:
SweepLine() {}
~SweepLine()
{
for (typename vector<Intersection<Segment<T,Point> >*>::iterator i = _Intersections.begin(),
iend = _Intersections.end();
i != iend;
i++)
{
delete (*i);
}
}
SweepLine() {}
~SweepLine()
{
for(typename vector<Intersection<Segment<T,Point> >*>::iterator i=_Intersections.begin(),iend=_Intersections.end();
i!=iend;
i++)
{
delete (*i);
}
}
inline void process(Point& p, vector<Segment<T,Point>*>& segments,
#if 0
binary_rule<Segment<T,Point>,Segment<T,Point> >& binrule = \
binary_rule<Segment<T,Point>,Segment<T,Point> >(),
#else
binary_rule<Segment<T,Point>,Segment<T,Point> >& binrule,
#endif
real epsilon = M_EPSILON)
{
// first we remove the segments that need to be removed and then we add the segments to add
vector<Segment<T,Point>*> toadd;
typename vector<Segment<T,Point>*>::iterator s, send;
for (s = segments.begin(), send = segments.end(); s != send; s++) {
if (p == (*(*s))[0])
toadd.push_back((*s));
else
remove((*s));
}
for (s = toadd.begin(), send = toadd.end(); s != send; s++) {
add((*s), binrule, epsilon);
}
}
inline void process(Point& p,
vector<Segment<T,Point>*>& segments,
binary_rule<Segment<T,Point>,Segment<T,Point> >& binrule,
//binary_rule<Segment<T,Point>,Segment<T,Point> >& binrule = binary_rule<Segment<T,Point>,Segment<T,Point> >(),
real epsilon = M_EPSILON
)
{
// first we remove the segments that need to be removed and then
// we add the segments to add
vector<Segment<T,Point>*> toadd;
typename vector<Segment<T,Point>*>::iterator s, send;
for(s=segments.begin(), send=segments.end();
s!=send;
s++)
{
if(p == (*(*s))[0])
toadd.push_back((*s));
else
remove((*s));
}
for(s=toadd.begin(), send=toadd.end();
s!=send;
s++)
{
add((*s), binrule, epsilon);
}
}
inline void add(Segment<T,Point>* S,
binary_rule<Segment<T,Point>,Segment<T,Point> >& binrule,
//binary_rule<Segment<T,Point>,Segment<T,Point> >& binrule = binary_rule<Segment<T,Point>, Segment<T,Point> >(),
real epsilon
)
{
real t,u;
Point CP;
Vec2r v0, v1, v2, v3;
if(true == S->order())
{
v0[0] = ((*S)[0])[0];
v0[1] = ((*S)[0])[1];
v1[0] = ((*S)[1])[0];
v1[1] = ((*S)[1])[1];
}
else
{
v1[0] = ((*S)[0])[0];
v1[1] = ((*S)[0])[1];
v0[0] = ((*S)[1])[0];
v0[1] = ((*S)[1])[1];
}
for(typename std::list<Segment<T,Point>* >::iterator s=_set.begin(), send=_set.end();
s!=send;
s++)
{
Segment<T,Point>* currentS = (*s);
if(true != binrule(*S, *currentS))
continue;
inline void add(Segment<T,Point>* S,
#if 0
binary_rule<Segment<T,Point>,Segment<T,Point> >& binrule = \
binary_rule<Segment<T,Point>, Segment<T,Point> >(),
#else
binary_rule<Segment<T,Point>,Segment<T,Point> >& binrule,
#endif
real epsilon)
{
real t,u;
Point CP;
Vec2r v0, v1, v2, v3;
if (true == S->order()) {
v0[0] = ((*S)[0])[0];
v0[1] = ((*S)[0])[1];
v1[0] = ((*S)[1])[0];
v1[1] = ((*S)[1])[1];
}
else {
v1[0] = ((*S)[0])[0];
v1[1] = ((*S)[0])[1];
v0[0] = ((*S)[1])[0];
v0[1] = ((*S)[1])[1];
}
for (typename std::list<Segment<T,Point>* >::iterator s = _set.begin(), send = _set.end(); s != send; s++) {
Segment<T,Point>* currentS = (*s);
if (true != binrule(*S, *currentS))
continue;
if(true == currentS->order())
{
v2[0] = ((*currentS)[0])[0];
v2[1] = ((*currentS)[0])[1];
v3[0] = ((*currentS)[1])[0];
v3[1] = ((*currentS)[1])[1];
}
else
{
v3[0] = ((*currentS)[0])[0];
v3[1] = ((*currentS)[0])[1];
v2[0] = ((*currentS)[1])[0];
v2[1] = ((*currentS)[1])[1];
}
if(S->CommonVertex(*currentS, CP))
continue; // the two edges have a common vertex->no need to check
if(GeomUtils::intersect2dSeg2dSegParametric(v0, v1, v2, v3, t, u, epsilon) == GeomUtils::DO_INTERSECT)
{
// create the intersection
Intersection<Segment<T,Point> > * inter = new Intersection<Segment<T,Point> >(S,t,currentS,u);
// add it to the intersections list
_Intersections.push_back(inter);
// add this intersection to the first edge intersections list
S->AddIntersection(inter);
// add this intersection to the second edge intersections list
currentS->AddIntersection(inter);
}
}
// add the added segment to the list of active segments
_set.push_back(S);
}
inline void remove(Segment<T,Point>* s)
{
if(s->intersections().size() > 0)
_IntersectedEdges.push_back(s);
_set.remove(s);
}
if (true == currentS->order()) {
v2[0] = ((*currentS)[0])[0];
v2[1] = ((*currentS)[0])[1];
v3[0] = ((*currentS)[1])[0];
v3[1] = ((*currentS)[1])[1];
}
else {
v3[0] = ((*currentS)[0])[0];
v3[1] = ((*currentS)[0])[1];
v2[0] = ((*currentS)[1])[0];
v2[1] = ((*currentS)[1])[1];
}
if (S->CommonVertex(*currentS, CP))
continue; // the two edges have a common vertex->no need to check
vector<Segment<T,Point>* >& intersectedEdges() {return _IntersectedEdges;}
vector<Intersection<Segment<T,Point> >*>& intersections() {return _Intersections;}
if (GeomUtils::intersect2dSeg2dSegParametric(v0, v1, v2, v3, t, u, epsilon) == GeomUtils::DO_INTERSECT) {
// create the intersection
Intersection<Segment<T,Point> > *inter = new Intersection<Segment<T,Point> >(S,t,currentS,u);
// add it to the intersections list
_Intersections.push_back(inter);
// add this intersection to the first edge intersections list
S->AddIntersection(inter);
// add this intersection to the second edge intersections list
currentS->AddIntersection(inter);
}
}
// add the added segment to the list of active segments
_set.push_back(S);
}
inline void remove(Segment<T,Point>* s)
{
if (s->intersections().size() > 0)
_IntersectedEdges.push_back(s);
_set.remove(s);
}
vector<Segment<T,Point>* >& intersectedEdges()
{
return _IntersectedEdges;
}
vector<Intersection<Segment<T,Point> >*>& intersections()
{
return _Intersections;
}
private:
std::list<Segment<T,Point>* > _set; // set of active edges for a given position of the sweep line
std::vector<Segment<T,Point>* > _IntersectedEdges; // the list of intersected edges
std::vector<Intersection<Segment<T,Point> >*> _Intersections; // the list of all intersections.
std::list<Segment<T,Point>* > _set; // set of active edges for a given position of the sweep line
std::vector<Segment<T,Point>* > _IntersectedEdges; // the list of intersected edges
std::vector<Intersection<Segment<T,Point> >*> _Intersections; // the list of all intersections.
};
#endif // SWEEPLINE_H
#endif // __SWEEPLINE_H__

1857
source/blender/freestyle/intern/geometry/VecMat.h
View File

File diff suppressed because it is too large Load Diff

489
source/blender/freestyle/intern/geometry/matrix_util.cpp
View File

@ -1,265 +1,266 @@
/*
* GXML/Graphite: Geometry and Graphics Programming Library + Utilities
* Copyright (C) 2000 Bruno Levy
* ***** 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 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.
* 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., 675 Mass Ave, Cambridge, MA 02139, USA.
* 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.
*
* If you modify this software, you should include a notice giving the
* name of the person performing the modification, the date of modification,
* and the reason for such modification.
* This Code is Copyright (C) 2010 Blender Foundation.
* All rights reserved.
*
* Contact: Bruno Levy
* The Original Code is:
* GXML/Graphite: Geometry and Graphics Programming Library + Utilities
* Copyright (C) 2000 Bruno Levy
* Contact: Bruno Levy
* levy@loria.fr
* ISA Project
* LORIA, INRIA Lorraine,
* Campus Scientifique, BP 239
* 54506 VANDOEUVRE LES NANCY CEDEX
* FRANCE
*
* levy@loria.fr
* Contributor(s): none yet.
*
* ISA Project
* LORIA, INRIA Lorraine,
* Campus Scientifique, BP 239
* 54506 VANDOEUVRE LES NANCY CEDEX
* FRANCE
*
* Note that the GNU General Public License does not permit incorporating
* the Software into proprietary programs.
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/freestyle/intern/geometry/matrix_util.cpp
* \ingroup freestyle
* \author Bruno Levy
*/
#include "matrix_util.h"
#include <math.h>
#include "matrix_util.h"
namespace OGF {
namespace MatrixUtil {
static const double EPS = 0.00001 ;
static int MAX_ITER = 100 ;
void semi_definite_symmetric_eigen(
const double *mat, int n, double *eigen_vec, double *eigen_val
) {
double *a,*v;
double a_norm,a_normEPS,thr,thr_nn;
int nb_iter = 0;
int jj;
int i,j,k,ij,ik,l,m,lm,mq,lq,ll,mm,imv,im,iq,ilv,il,nn;
int *index;
double a_ij,a_lm,a_ll,a_mm,a_im,a_il;
double a_lm_2;
double v_ilv,v_imv;
double x;
double sinx,sinx_2,cosx,cosx_2,sincos;
double delta;
// Number of entries in mat
nn = (n*(n+1))/2;
// Step 1: Copy mat to a
a = new double[nn];
for( ij=0; ij<nn; ij++ ) {
a[ij] = mat[ij];
}
// Ugly Fortran-porting trick: indices for a are between 1 and n
a--;
// Step 2 : Init diagonalization matrix as the unit matrix
v = new double[n*n];
ij = 0;
for( i=0; i<n; i++ ) {
for( j=0; j<n; j++ ) {
if( i==j ) {
v[ij++] = 1.0;
} else {
v[ij++] = 0.0;
}
}
}
// Ugly Fortran-porting trick: indices for v are between 1 and n
v--;
// Step 3 : compute the weight of the non diagonal terms
ij = 1 ;
a_norm = 0.0;
for( i=1; i<=n; i++ ) {
for( j=1; j<=i; j++ ) {
if( i!=j ) {
a_ij = a[ij];
a_norm += a_ij*a_ij;
}
ij++;
}
}
if( a_norm != 0.0 ) {
a_normEPS = a_norm*EPS;
thr = a_norm ;
// Step 4 : rotations
while( thr > a_normEPS && nb_iter < MAX_ITER ) {
nb_iter++;
thr_nn = thr / nn;
for( l=1 ; l< n; l++ ) {
for( m=l+1; m<=n; m++ ) {
// compute sinx and cosx
lq = (l*l-l)/2;
mq = (m*m-m)/2;
lm = l+mq;
a_lm = a[lm];
a_lm_2 = a_lm*a_lm;
if( a_lm_2 < thr_nn ) {
continue ;
}
ll = l+lq;
mm = m+mq;
a_ll = a[ll];
a_mm = a[mm];
delta = a_ll - a_mm;
if( delta == 0.0 ) {
x = - M_PI/4 ;
} else {
x = - atan( (a_lm+a_lm) / delta ) / 2.0 ;
}
namespace MatrixUtil {
sinx = sin(x) ;
cosx = cos(x) ;
sinx_2 = sinx*sinx;
cosx_2 = cosx*cosx;
sincos = sinx*cosx;
// rotate L and M columns
ilv = n*(l-1);
imv = n*(m-1);
for( i=1; i<=n;i++ ) {
if( (i!=l) && (i!=m) ) {
iq = (i*i-i)/2;
if( i<m ) {
im = i + mq;
} else {
im = m + iq;
}
a_im = a[im];
if( i<l ) {
il = i + lq;
} else {
il = l + iq;
}
a_il = a[il];
a[il] = a_il*cosx - a_im*sinx;
a[im] = a_il*sinx + a_im*cosx;
}
ilv++;
imv++;
v_ilv = v[ilv];
v_imv = v[imv];
v[ilv] = cosx*v_ilv - sinx*v_imv;
v[imv] = sinx*v_ilv + cosx*v_imv;
}
x = a_lm*sincos; x+=x;
a[ll] = a_ll*cosx_2 + a_mm*sinx_2 - x;
a[mm] = a_ll*sinx_2 + a_mm*cosx_2 + x;
a[lm] = 0.0;
thr = fabs( thr - a_lm_2 );
}
}
}
}
// Step 5: index conversion and copy eigen values
// back from Fortran to C++
a++;
for( i=0; i<n; i++ ) {
k = i + (i*(i+1))/2;
eigen_val[i] = a[k];
}
delete[] a;
// Step 6: sort the eigen values and eigen vectors
index = new int[n];
for( i=0; i<n; i++ ) {
index[i] = i;
}
for( i=0; i<(n-1); i++ ) {
x = eigen_val[i];
k = i;
for( j=i+1; j<n; j++ ) {
if( x < eigen_val[j] ) {
k = j;
x = eigen_val[j];
}
}
eigen_val[k] = eigen_val[i];
eigen_val[i] = x;
jj = index[k];
index[k] = index[i];
index[i] = jj;
}
static const double EPS = 0.00001;
static int MAX_ITER = 100;
void semi_definite_symmetric_eigen(const double *mat, int n, double *eigen_vec, double *eigen_val)
{
double *a, *v;
double a_norm, a_normEPS, thr, thr_nn;
int nb_iter = 0;
int jj;
int i, j, k, ij, ik, l, m, lm, mq, lq, ll, mm, imv, im, iq, ilv, il, nn;
int *index;
double a_ij, a_lm, a_ll, a_mm, a_im, a_il;
double a_lm_2;
double v_ilv, v_imv;
double x;
double sinx, sinx_2, cosx, cosx_2, sincos;
double delta;
// Number of entries in mat
nn = (n * (n + 1)) / 2;
// Step 1: Copy mat to a
a = new double[nn];
for (ij = 0; ij < nn; ij++) {
a[ij] = mat[ij];
}
// Ugly Fortran-porting trick: indices for a are between 1 and n
a--;
// Step 2 : Init diagonalization matrix as the unit matrix
v = new double[n * n];
ij = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if (i == j) {
v[ij++] = 1.0;
}
else {
v[ij++] = 0.0;
}
}
}
// Ugly Fortran-porting trick: indices for v are between 1 and n
v--;
// Step 3 : compute the weight of the non diagonal terms
ij = 1;
a_norm = 0.0;
for (i = 1; i <= n; i++) {
for (j = 1; j <= i; j++) {
if (i != j) {
a_ij = a[ij];
a_norm += a_ij * a_ij;
}
ij++;
}
}
if (a_norm != 0.0) {
a_normEPS = a_norm * EPS;
thr = a_norm;
// Step 4 : rotations
while (thr > a_normEPS && nb_iter < MAX_ITER) {
nb_iter++;
thr_nn = thr / nn;
for (l = 1; l < n; l++) {
for (m = l + 1; m <= n; m++) {
// compute sinx and cosx
lq = (l * l - l) / 2;
mq = (m * m - m) / 2;
lm = l + mq;
a_lm = a[lm];
a_lm_2 = a_lm * a_lm;
if (a_lm_2 < thr_nn) {
continue;
}
ll = l + lq;
mm = m + mq;
a_ll = a[ll];
a_mm = a[mm];
delta = a_ll - a_mm;
if (delta == 0.0) {
x = -M_PI / 4;
}
else {
x = -atan((a_lm + a_lm) / delta) / 2.0;
}
sinx = sin(x);
cosx = cos(x);
sinx_2 = sinx * sinx;
cosx_2 = cosx * cosx;
sincos = sinx * cosx;
// rotate L and M columns
ilv = n * (l - 1);
imv = n * (m - 1);
for (i = 1; i <= n; i++) {
if ((i != l) && (i != m)) {
iq = (i * i - i) / 2;
if (i < m) {
im = i + mq;
}
else {
im = m + iq;
}
a_im = a[im];
if (i < l) {
il = i + lq;
}
else {
il = l + iq;
}
a_il = a[il];
a[il] = a_il * cosx - a_im * sinx;
a[im] = a_il * sinx + a_im * cosx;
}
ilv++;
imv++;
v_ilv = v[ilv];
v_imv = v[imv];
v[ilv] = cosx * v_ilv - sinx * v_imv;
v[imv] = sinx * v_ilv + cosx * v_imv;
}
x = a_lm * sincos;
x += x;
a[ll] = a_ll * cosx_2 + a_mm * sinx_2 - x;
a[mm] = a_ll * sinx_2 + a_mm * cosx_2 + x;
a[lm] = 0.0;
thr = fabs(thr - a_lm_2);
}
}
}
}
// Step 5: index conversion and copy eigen values
// back from Fortran to C++
a++;
for (i = 0; i < n; i++) {
k = i + (i * (i + 1)) / 2;
eigen_val[i] = a[k];
}
delete[] a;
// Step 6: sort the eigen values and eigen vectors
index = new int[n];
for (i = 0; i < n; i++) {
index[i] = i;
}
for (i = 0; i < (n - 1); i++) {
x = eigen_val[i];
k = i;
for (j = i + 1; j < n; j++) {
if (x < eigen_val[j]) {
k = j;
x = eigen_val[j];
}
}
eigen_val[k] = eigen_val[i];
eigen_val[i] = x;
jj = index[k];
index[k] = index[i];
index[i] = jj;
}
// Step 7: save the eigen vectors
// back from Fortran to to C++
v++;
ij = 0;
for (k = 0; k < n; k++) {
ik = index[k] * n;
for (i = 0; i < n; i++) {
eigen_vec[ij++] = v[ik++];
}
}
delete[] v;
delete[] index;
return;
}
// Step 7: save the eigen vectors
v++; // back from Fortran to to C++
ij = 0;
for( k=0; k<n; k++ ) {
ik = index[k]*n;
for( i=0; i<n; i++ ) {
eigen_vec[ij++] = v[ik++];
}
}
delete[] v ;
delete[] index;
return;
}
//_________________________________________________________
}
}
} // MatrixUtil namespace
} // OGF namespace

105
source/blender/freestyle/intern/geometry/matrix_util.h
View File

@ -1,69 +1,72 @@
/*
* GXML/Graphite: Geometry and Graphics Programming Library + Utilities
* Copyright (C) 2000 Bruno Levy
* ***** 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 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.
* 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., 675 Mass Ave, Cambridge, MA 02139, USA.
* 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.
*
* If you modify this software, you should include a notice giving the
* name of the person performing the modification, the date of modification,
* and the reason for such modification.
* This Code is Copyright (C) 2010 Blender Foundation.
* All rights reserved.
*
* Contact: Bruno Levy
* The Original Code is:
* GXML/Graphite: Geometry and Graphics Programming Library + Utilities
* Copyright (C) 2000 Bruno Levy
* Contact: Bruno Levy
* levy@loria.fr
* ISA Project
* LORIA, INRIA Lorraine,
* Campus Scientifique, BP 239
* 54506 VANDOEUVRE LES NANCY CEDEX
* FRANCE
*
* levy@loria.fr
* Contributor(s): none yet.
*
* ISA Project
* LORIA, INRIA Lorraine,
* Campus Scientifique, BP 239
* 54506 VANDOEUVRE LES NANCY CEDEX
* FRANCE
*
* Note that the GNU General Public License does not permit incorporating
* the Software into proprietary programs.
* ***** END GPL LICENSE BLOCK *****
*/
#ifndef __MATRIX_UTIL__
#define __MATRIX_UTIL__
# include "../system/FreestyleConfig.h"
/** \file blender/freestyle/intern/geometry/matrix_util.h
* \ingroup freestyle
* \author Bruno Levy
*/
#include "../system/FreestyleConfig.h"
namespace OGF {
namespace MatrixUtil {
namespace MatrixUtil {
/**
* computes the eigen values and eigen vectors
* of a semi definite symmetric matrix
*
* @param matrix is stored in column symmetric storage, i.e.
* matrix = { m11, m12, m22, m13, m23, m33, m14, m24, m34, m44 ... }
* size = n(n+1)/2
*
* @param eigen_vectors (return) = { v1, v2, v3, ..., vn }
* where vk = vk0, vk1, ..., vkn
* size = n^2, must be allocated by caller
*
* @param eigen_values (return) are in decreasing order
* size = n, must be allocated by caller
*/
LIB_GEOMETRY_EXPORT
void semi_definite_symmetric_eigen(
const double *mat, int n, double *eigen_vec, double *eigen_val
) ;
}
}
/**
* computes the eigen values and eigen vectors of a semi definite symmetric matrix
*
* @param matrix is stored in column symmetric storage, i.e.
* matrix = { m11, m12, m22, m13, m23, m33, m14, m24, m34, m44 ... }
* size = n(n+1)/2
*
* @param eigen_vectors (return) = { v1, v2, v3, ..., vn }
* where vk = vk0, vk1, ..., vkn
* size = n^2, must be allocated by caller
*
* @param eigen_values (return) are in decreasing order
* size = n, must be allocated by caller
*/
LIB_GEOMETRY_EXPORT
void semi_definite_symmetric_eigen(const double *mat, int n, double *eigen_vec, double *eigen_val);
#endif
} // MatrixUtil namespace
} // OGF namespace
#endif // __MATRIX_UTIL__

157
source/blender/freestyle/intern/geometry/normal_cycle.cpp
View File

@ -1,87 +1,100 @@
/*
* ***** 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.
*
* This Code is Copyright (C) 2010 Blender Foundation.
* All rights reserved.
*
* The Original Code is:
* OGF/Graphite: Geometry and Graphics Programming Library + Utilities
* Copyright (C) 2000 Bruno Levy
* Contact: Bruno Levy
* levy@loria.fr
* ISA Project
* LORIA, INRIA Lorraine,
* Campus Scientifique, BP 239
* 54506 VANDOEUVRE LES NANCY CEDEX
* FRANCE
*
* Contributor(s): none yet.
*
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/freestyle/intern/geometry/normal_cycle.cpp
* \ingroup freestyle
* \author Bruno Levy
*/
//
// 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 "normal_cycle.h"
#include "matrix_util.h"
#include "normal_cycle.h"
namespace OGF {
//_________________________________________________________
NormalCycle::NormalCycle() {
}
void NormalCycle::begin() {
M_[0] = M_[1] = M_[2] = M_[3] = M_[4] = M_[5] = 0 ;
}
void NormalCycle::end() {
double eigen_vectors[9] ;
MatrixUtil::semi_definite_symmetric_eigen(M_, 3, eigen_vectors, eigen_value_) ;
axis_[0] = Vec3r(
eigen_vectors[0], eigen_vectors[1], eigen_vectors[2]
) ;
axis_[1] = Vec3r(
eigen_vectors[3], eigen_vectors[4], eigen_vectors[5]
) ;
axis_[2] = Vec3r(
eigen_vectors[6], eigen_vectors[7], eigen_vectors[8]
) ;
// Normalize the eigen vectors
for(int i=0; i<3; i++) {
axis_[i].normalize() ;
}
NormalCycle::NormalCycle()
{
}
// Sort the eigen vectors
void NormalCycle::begin()
{
M_[0] = M_[1] = M_[2] = M_[3] = M_[4] = M_[5] = 0;
}
i_[0] = 0 ;
i_[1] = 1 ;
i_[2] = 2 ;
void NormalCycle::end()
{
double eigen_vectors[9];
MatrixUtil::semi_definite_symmetric_eigen(M_, 3, eigen_vectors, eigen_value_);
double l0 = ::fabs(eigen_value_[0]) ;
double l1 = ::fabs(eigen_value_[1]) ;
double l2 = ::fabs(eigen_value_[2]) ;
if(l1 > l0) {
ogf_swap(l0 , l1 ) ;
ogf_swap(i_[0], i_[1]) ;
}
if(l2 > l1) {
ogf_swap(l1 , l2 ) ;
ogf_swap(i_[1], i_[2]) ;
}
if(l1 > l0) {
ogf_swap(l0 , l1 ) ;
ogf_swap(i_[0],i_[1]) ;
}
axis_[0] = Vec3r(eigen_vectors[0], eigen_vectors[1], eigen_vectors[2]);
}
axis_[1] = Vec3r(eigen_vectors[3], eigen_vectors[4], eigen_vectors[5]);
axis_[2] = Vec3r(eigen_vectors[6], eigen_vectors[7], eigen_vectors[8]);
// Normalize the eigen vectors
for (int i = 0; i < 3; i++) {
axis_[i].normalize();
}
// Sort the eigen vectors
i_[0] = 0;
i_[1] = 1;
i_[2] = 2;
double l0 = ::fabs(eigen_value_[0]);
double l1 = ::fabs(eigen_value_[1]);
double l2 = ::fabs(eigen_value_[2]);
if (l1 > l0) {
ogf_swap(l0 , l1 );
ogf_swap(i_[0], i_[1]);
}
if (l2 > l1) {
ogf_swap(l1 , l2 );
ogf_swap(i_[1], i_[2]);
}
if (l1 > l0) {
ogf_swap(l0 , l1 );
ogf_swap(i_[0], i_[1]);
}
}
//_________________________________________________________
}
} // OGF namespace

218
source/blender/freestyle/intern/geometry/normal_cycle.h
View File

@ -1,110 +1,144 @@
/*
* OGF/Graphite: Geometry and Graphics Programming Library + Utilities
* Copyright (C) 2000 Bruno Levy
* ***** 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 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.
* 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., 675 Mass Ave, Cambridge, MA 02139, USA.
* 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.
*
* If you modify this software, you should include a notice giving the
* name of the person performing the modification, the date of modification,
* and the reason for such modification.
* This Code is Copyright (C) 2010 Blender Foundation.
* All rights reserved.
*
* Contact: Bruno Levy
* The Original Code is:
* OGF/Graphite: Geometry and Graphics Programming Library + Utilities
* Copyright (C) 2000 Bruno Levy
* Contact: Bruno Levy
* levy@loria.fr
* ISA Project
* LORIA, INRIA Lorraine,
* Campus Scientifique, BP 239
* 54506 VANDOEUVRE LES NANCY CEDEX
* FRANCE
*
* levy@loria.fr
* Contributor(s): none yet.
*
* ISA Project
* LORIA, INRIA Lorraine,
* Campus Scientifique, BP 239
* 54506 VANDOEUVRE LES NANCY CEDEX
* FRANCE
*
* Note that the GNU General Public License does not permit incorporating
* the Software into proprietary programs.
* ***** END GPL LICENSE BLOCK *****
*/
#ifndef __MESH_TOOLS_MATH_NORMAL_CYCLE__
#define __MESH_TOOLS_MATH_NORMAL_CYCLE__
# include "../system/FreestyleConfig.h"
# include "Geom.h"
/** \file blender/freestyle/intern/geometry/normal_cycle.h
* \ingroup freestyle
* \author Bruno Levy
*/
#include "Geom.h"
#include "../system/FreestyleConfig.h"
using namespace Geometry;
namespace OGF {
template <class T> inline void ogf_swap(T& x, T& y) {
T z = x ;
x = y ;
y = z ;
}
//_________________________________________________________
/**
* NormalCycle evaluates the curvature tensor in function
* of a set of dihedral angles and associated vectors.
* Reference:
* Restricted Delaunay Triangulation and Normal Cycle,
* D. Cohen-Steiner and J.M. Morvan,
* SOCG 2003
*/
class LIB_GEOMETRY_EXPORT NormalCycle {
public:
NormalCycle() ;
void begin() ;
void end() ;
/**
* Note: the specified edge vector needs to be pre-clipped
* by the neighborhood.
*/
void accumulate_dihedral_angle(
const Vec3r& edge, real angle, real neigh_area = 1.0
) ;
const Vec3r& eigen_vector(int i) const { return axis_[i_[i]] ; }
real eigen_value(int i) const { return eigen_value_[i_[i]] ; }
const Vec3r& N() const { return eigen_vector(2) ; }
const Vec3r& Kmax() const { return eigen_vector(1) ; }
const Vec3r& Kmin() const { return eigen_vector(0) ; }
real n() const { return eigen_value(2) ; }
real kmax() const { return eigen_value(1) ; }
real kmin() const { return eigen_value(0) ; }
private:
real center_[3] ;
Vec3r axis_[3] ;
real eigen_value_[3] ;
real M_[6] ;
int i_[3] ;
} ;
inline void NormalCycle::accumulate_dihedral_angle(
const Vec3r& edge, const double beta, double neigh_area
) {
double s = beta * neigh_area / edge.norm();
M_[0] += s * edge.x() * edge.x() ;
M_[1] += s * edge.x() * edge.y() ;
M_[2] += s * edge.y() * edge.y() ;
M_[3] += s * edge.x() * edge.z() ;
M_[4] += s * edge.y() * edge.z() ;
M_[5] += s * edge.z() * edge.z() ;
}
//_________________________________________________________
template <class T> inline void ogf_swap(T& x, T& y)
{
T z = x ;
x = y ;
y = z ;
}
#endif
//_________________________________________________________
/**
* NormalCycle evaluates the curvature tensor in function
* of a set of dihedral angles and associated vectors.
* Reference:
* Restricted Delaunay Triangulation and Normal Cycle,
* D. Cohen-Steiner and J.M. Morvan,
* SOCG 2003
*/
class LIB_GEOMETRY_EXPORT NormalCycle {
public:
NormalCycle();
void begin();
void end();
/**
* Note: the specified edge vector needs to be pre-clipped by the neighborhood.
*/
void accumulate_dihedral_angle(const Vec3r& edge, real angle, real neigh_area = 1.0);
const Vec3r& eigen_vector(int i) const
{
return axis_[i_[i]];
}
real eigen_value(int i) const
{
return eigen_value_[i_[i]];
}
const Vec3r& N() const
{
return eigen_vector(2);
}
const Vec3r& Kmax() const
{
return eigen_vector(1);
}
const Vec3r& Kmin() const
{
return eigen_vector(0);
}
real n() const
{
return eigen_value(2);
}
real kmax() const
{
return eigen_value(1);
}
real kmin() const
{
return eigen_value(0);
}
private:
real center_[3];
Vec3r axis_[3];
real eigen_value_[3];
real M_[6];
int i_[3];
};
inline void NormalCycle::accumulate_dihedral_angle(const Vec3r& edge, const double beta, double neigh_area)
{
double s = beta * neigh_area / edge.norm();
M_[0] += s * edge.x() * edge.x();
M_[1] += s * edge.x() * edge.y();
M_[2] += s * edge.y() * edge.y();
M_[3] += s * edge.x() * edge.z();
M_[4] += s * edge.y() * edge.z();
M_[5] += s * edge.z() * edge.z();
}
//_________________________________________________________
} // OGF namespace
#endif // __MESH_TOOLS_MATH_NORMAL_CYCLE__

144
source/blender/freestyle/intern/image/GaussianFilter.cpp
View File

@ -1,96 +1,112 @@
/*
* ***** 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/image/GaussianFilter.cpp
* \ingroup freestyle
* \brief Class to perform gaussian filtering operations on an image
* \author Stephane Grabli
* \date 20/05/2003
*/
#include "GaussianFilter.h"
#include <stdlib.h>
GaussianFilter::GaussianFilter(float iSigma )
#include "GaussianFilter.h"
GaussianFilter::GaussianFilter(float iSigma)
{
_sigma = iSigma;
_mask = 0;
computeMask();
_sigma = iSigma;
_mask = 0;
computeMask();
}
GaussianFilter::GaussianFilter(const GaussianFilter& iBrother)
GaussianFilter::GaussianFilter(const GaussianFilter& iBrother)
{
_sigma = iBrother._sigma;
_maskSize = iBrother._maskSize;
_bound = iBrother._bound;
_storedMaskSize = iBrother._storedMaskSize;
_mask = new float[_maskSize*_maskSize];
memcpy(_mask, iBrother._mask, _maskSize*_maskSize*sizeof(float));
_sigma = iBrother._sigma;
_maskSize = iBrother._maskSize;
_bound = iBrother._bound;
_storedMaskSize = iBrother._storedMaskSize;
_mask = new float[_maskSize * _maskSize];
memcpy(_mask, iBrother._mask, _maskSize * _maskSize * sizeof(float));
}
GaussianFilter& GaussianFilter::operator= (const GaussianFilter& iBrother)
GaussianFilter& GaussianFilter::operator=(const GaussianFilter& iBrother)
{
_sigma = iBrother._sigma;
_maskSize = iBrother._maskSize;
_bound = iBrother._bound;
_storedMaskSize = iBrother._storedMaskSize;
_mask = new float[_storedMaskSize*_storedMaskSize];
memcpy(_mask, iBrother._mask, _storedMaskSize*_storedMaskSize*sizeof(float));
return *this;
_sigma = iBrother._sigma;
_maskSize = iBrother._maskSize;
_bound = iBrother._bound;
_storedMaskSize = iBrother._storedMaskSize;
_mask = new float[_storedMaskSize * _storedMaskSize];
memcpy(_mask, iBrother._mask, _storedMaskSize * _storedMaskSize * sizeof(float));
return *this;
}
GaussianFilter::~GaussianFilter()
{
if(0!=_mask)
{
delete [] _mask;
}
if (0 != _mask) {
delete[] _mask;
}
}
int GaussianFilter::computeMaskSize(float sigma)
{
int maskSize = (int)floor(4*sigma)+1;
if(0 == maskSize%2)
++maskSize;
int maskSize = (int)floor(4 * sigma) + 1;
if (0 == (maskSize % 2))
++maskSize;
return maskSize;
return maskSize;
}
void GaussianFilter::setSigma(float sigma)
{
_sigma = sigma;
computeMask();
_sigma = sigma;
computeMask();
}
void GaussianFilter::computeMask()
{
if(0 != _mask){
delete [] _mask;
}
if (0 != _mask) {
delete[] _mask;
}
_maskSize = computeMaskSize(_sigma);
_storedMaskSize = (_maskSize+1)>>1;
_bound = _storedMaskSize-1;
_maskSize = computeMaskSize(_sigma);
_storedMaskSize = (_maskSize + 1) >> 1;
_bound = _storedMaskSize - 1;
float norm = _sigma*_sigma*2.f*M_PI;
float invNorm = 1.0/norm;
_mask = new float[_storedMaskSize*_storedMaskSize*sizeof(float)];
for(int i=0; i<_storedMaskSize; ++i)
for(int j=0; j<_storedMaskSize; ++j)
_mask[i*_storedMaskSize+j] = invNorm*exp(-(i*i + j*j)/(2.0*_sigma*_sigma));
//_mask[i*_storedMaskSize+j] = exp(-(i*i + j*j)/(2.0*_sigma*_sigma));
float norm = _sigma * _sigma * 2.0f * M_PI;
float invNorm = 1.0f / norm;
_mask = new float[_storedMaskSize * _storedMaskSize * sizeof(float)];
for (int i = 0; i < _storedMaskSize; ++i) {
for (int j = 0; j < _storedMaskSize; ++j) {
#if 0
_mask[i * _storedMaskSize + j] = exp(-(i * i + j * j) / (2.0 * _sigma * _sigma));
#else
_mask[i * _storedMaskSize + j] = invNorm * exp(-(i * i + j * j) / (2.0 * _sigma * _sigma));
#endif
}
}
}

231
source/blender/freestyle/intern/image/GaussianFilter.h
View File

@ -1,95 +1,114 @@
//
// Filename : Image.h
// Author(s) : Stephane Grabli
// Purpose : Class to perform gaussian filtering operations on an image
// Date of creation : 20/05/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 __GAUSSIANFILTER_H__
#define __GAUSSIANFILTER_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/image/GaussianFilter.h
* \ingroup freestyle
* \brief Class to perform gaussian filtering operations on an image
* \author Stephane Grabli
* \date 20/05/2003
*/
#ifndef GAUSSIANFILTER_H
# define GAUSSIANFILTER_H
#include <string.h> // for memcpy
#include <cstdlib> // for abs
#include <string.h> // for memcpy
#include "../system/FreestyleConfig.h"
class LIB_IMAGE_EXPORT GaussianFilter{
class LIB_IMAGE_EXPORT GaussianFilter
{
protected:
/* the mask is a symetrical 2d array (with respect
to the middle point).
Thus, M(i,j) = M(-i,j) = M(i,-j) = M(-i,-j).
For this reason, to represent a NxN array (N odd), we only store
a ((N+1)/2)x((N+1)/2) array.
*/
float _sigma;
float *_mask;
int _bound;
int _maskSize; // the real mask size (must be odd)(the size of the mask we store is ((_maskSize+1)/2)*((_maskSize+1)/2))
int _storedMaskSize; //(_maskSize+1)/2)
/* The mask is a symetrical 2d array (with respect to the middle point).
* Thus, M(i,j) = M(-i,j) = M(i,-j) = M(-i,-j).
* For this reason, to represent a NxN array (N odd), we only store a ((N+1)/2)x((N+1)/2) array.
*/
float _sigma;
float *_mask;
int _bound;
int _maskSize; // the real mask size (must be odd)(the size of the mask we store is ((_maskSize+1)/2)*((_maskSize+1)/2))
int _storedMaskSize; // (_maskSize+1)/2)
public:
GaussianFilter(float iSigma = 1.f) ;
GaussianFilter(const GaussianFilter&) ;
GaussianFilter& operator= (const GaussianFilter&) ;
virtual ~GaussianFilter() ;
GaussianFilter(float iSigma = 1.0f);
GaussianFilter(const GaussianFilter&);
GaussianFilter& operator=(const GaussianFilter&);
virtual ~GaussianFilter();
/*! Returns the value for pixel x,y of image "map" after a gaussian blur,
* made using the sigma value.
* The sigma value determines the mask size (~ 2 x sigma).
* \param map
* The image we wish to work on. The Map template must implement the
* foloowing methods:
* - float pixel(unsigned int x,unsigned int y) const;
* - unsigned width() const;
* - unsigned height() const;
* \param x
* The abscissa of the pixel where we want to evaluate the gaussian blur.
* \param y
* The ordinate of the pixel where we want to evaluate the gaussian blur.
* \param sigma
* The sigma value of the gaussian function.
*/
template<class Map>
float getSmoothedPixel(Map * map, int x, int y) ;
/*! Compute the mask size and returns the REAL mask size ((2*_maskSize)-1)
* This method is provided for convenience.
*/
static int computeMaskSize(float sigma) ;
/*! Returns the value for pixel x,y of image "map" after a gaussian blur, made using the sigma value.
* The sigma value determines the mask size (~ 2 x sigma).
* \param map
* The image we wish to work on. The Map template must implement the following methods:
* - float pixel(unsigned int x,unsigned int y) const;
* - unsigned width() const;
* - unsigned height() const;
* \param x
* The abscissa of the pixel where we want to evaluate the gaussian blur.
* \param y
* The ordinate of the pixel where we want to evaluate the gaussian blur.
* \param sigma
* The sigma value of the gaussian function.
*/
template<class Map>
float getSmoothedPixel(Map *map, int x, int y);
/*! accessors */
inline float sigma() const {return _sigma;}
inline int maskSize() const {return _maskSize;}
inline int getBound() {return _bound;}
/*! Compute the mask size and returns the REAL mask size ((2*_maskSize)-1)
* This method is provided for convenience.
*/
static int computeMaskSize(float sigma);
/*! accessors */
inline float sigma() const
{
return _sigma;
}
inline int maskSize() const
{
return _maskSize;
}
inline int getBound()
{
return _bound;
}
/*! modifiers */
void setSigma(float sigma);
#if 0
void SetMaskSize(int size)
{
_maskSize = size;
_storedMaskSize = (_maskSize + 1) >> 1;
}
#endif
/*! modifiers */
void setSigma(float sigma) ;
// void SetMaskSize(int size) {_maskSize = size;_storedMaskSize=(_maskSize+1)>>1;}
protected:
void computeMask();
void computeMask();
};
/*
@ -106,41 +125,37 @@ protected:
*/
#include <math.h>
#ifdef __MACH__
#define sqrtf(x) (sqrt(x))
# define sqrtf(x) (sqrt(x))
#endif
template<class Map>
float GaussianFilter::getSmoothedPixel(Map * map, int x, int y)
float GaussianFilter::getSmoothedPixel(Map *map, int x, int y)
{
float sum = 0.f;
float L=0.f;
int w = (int)map->width(); //soc
int h = (int)map->height(); //soc
float sum = 0.0f;
float L = 0.0f;
int w = (int)map->width(); //soc
int h = (int)map->height(); //soc
// Current pixel is x,y
// Sum surrounding pixels L value:
for(int i=-_bound; i<=_bound; ++i)
{
if((y+i < 0) || (y+i >= h))
continue;
for(int j=-_bound; j<=_bound; ++j)
{
if((x+j < 0) || (x+j >= w))
continue;
float tmpL = map->pixel(x+j,y+i);
float m = _mask[abs(i)*_storedMaskSize+abs(j)];
L += m*tmpL;
sum += m;
}
}
//L /= sum;
return L;
// Current pixel is x,y
// Sum surrounding pixels L value:
for (int i = -_bound; i <= _bound; ++i) {
if ((y + i < 0) || (y + i >= h))
continue;
for (int j = -_bound; j <= _bound; ++j) {
if ((x + j < 0) || (x + j >= w))
continue;
float tmpL = map->pixel(x + j, y + i);
float m = _mask[abs(i) * _storedMaskSize + abs(j)];
L += m * tmpL;
sum += m;
}
}
//L /= sum;
return L;
}
#endif // GAUSSIANFILTER
#endif // __GAUSSIANFILTER_H__

666
source/blender/freestyle/intern/image/Image.h
View File

@ -1,178 +1,177 @@
//
// Filename : Image.h
// Author(s) : Stephane Grabli
// Purpose : Class to encapsulate an array of RGB or Gray level values
// Date of creation : 20/05/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 __IMAGE_H__
#define __IMAGE_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/image/Image.h
* \ingroup freestyle
* \brief Class to encapsulate an array of RGB or Gray level values
* \author Stephane Grabli
* \date 20/05/2003
*/
#ifndef IMAGE_H
# define IMAGE_H
# include <string.h> // for memcpy
#include <string.h> // for memcpy
//
// Image base class, for all types of images
//
///////////////////////////////////////////////////////////////////////////////
/*! This class allows the storing of part of an image,
* while allowing a normal access to its pixel values.
* You can for example only a rectangle of sw*sh, whose
* lower-left corner is at (ox, oy), of an image of
* size w*h, and access these pixels using x,y coordinates
* specified in the whole image coordinate system.
/*! This class allows the storing of part of an image, while allowing a normal access to its pixel values.
* You can for example only a rectangle of sw*sh, whose lower-left corner is at (ox, oy), of an image of
* size w*h, and access these pixels using x,y coordinates specified in the whole image coordinate system.
*/
class FrsImage
{
public:
public:
/*! Default constructor */
FrsImage()
{
_storedWidth = 0;
_storedHeight = 0;
_width = 0;
_height = 0;
_Ox = 0;
_Oy = 0;
}
/*! Default constructor */
FrsImage() {
_storedWidth = 0;
_storedHeight = 0;
_width = 0;
_height = 0;
_Ox = 0;
_Oy = 0;
}
/*! Copy constructor */
FrsImage(const FrsImage& brother)
{
_storedWidth = brother._storedWidth;
_storedHeight = brother._storedHeight;
_width = brother._width;
_height = brother._height;
_Ox = brother._Ox;
_Oy = brother._Oy;
}
/*! Copy constructor */
FrsImage(const FrsImage& brother) {
_storedWidth = brother._storedWidth;
_storedHeight = brother._storedHeight;
_width = brother._width;
_height = brother._height;
_Ox = brother._Ox;
_Oy = brother._Oy;
}
/*! Builds an FrsImage from its width and height.
* The memory is allocated consequently.
*/
FrsImage(unsigned w, unsigned h)
{
_width = w;
_height = h;
_storedWidth = w;
_storedHeight = h;
_Ox = 0;
_Oy = 0;
}
/*! Builds an FrsImage from its width and height.
* The memory is allocated consequently.
*/
FrsImage(unsigned w, unsigned h) {
_width = w;
_height = h;
_storedWidth = w;
_storedHeight = h;
_Ox = 0;
_Oy = 0;
}
/*! Builds a partial-storing image.
* \param w
* The width of the complete image
* \param h
* The height of the complete image
* \param sw
* The width of the rectangle that will actually be stored.
* \param sh
* The height of the rectangle that will actually be stored.
* \param ox
* The x-abscissa of the origin of the rectangle that will actually be stored.
* \param oy
* The x-abscissa of the origin of the rectangle that will actually be stored.
*/
FrsImage(unsigned w, unsigned h, unsigned sw, unsigned sh, unsigned ox, unsigned oy)
{
_width = w;
_height = h;
_storedWidth = sw;
_storedHeight = sh;
_Ox = ox;
_Oy = oy;
}
/*! Builds a partial-storing image.
* \param w
* The width of the complete image
* \param h
* The height of the complete image
* \param sw
* The width of the rectangle that will actually
* be stored.
* \param sh
* The height of the rectangle that will actually
* be stored.
* \param ox
* The x-abscissa of the origin of the rectangle that will actually
* be stored.
* \param oy
* The x-abscissa of the origin of the rectangle that will actually
* be stored.
*/
FrsImage(unsigned w, unsigned h, unsigned sw, unsigned sh, unsigned ox, unsigned oy) {
_width = w;
_height = h;
_storedWidth = sw;
_storedHeight = sh;
_Ox = ox;
_Oy = oy;
}
/*! Operator= */
FrsImage& operator=(const FrsImage& brother)
{
_width = brother._width;
_height = brother._height;
_storedWidth = brother._storedWidth;
_storedHeight = brother._storedHeight;
_Ox = brother._Ox;
_Oy = brother._Oy;
return *this;
}
/*! Operator= */
FrsImage& operator=(const FrsImage& brother) {
_width = brother._width;
_height = brother._height;
_storedWidth = brother._storedWidth;
_storedHeight = brother._storedHeight;
_Ox = brother._Ox;
_Oy = brother._Oy;
return* this;
}
/*! Destructor */
virtual ~FrsImage() {}
/*! Destructor */
virtual ~FrsImage() {}
/*! Returns the width of the complete image */
inline unsigned width() const
{
return _width;
}
/*! Returns the width of the complete image */
inline unsigned width() const {
return _width;
}
/*! Returns the height of the complete image */
inline unsigned height() const {
return _height;
}
/*! Returns the grey value for pixel x,y */
virtual float pixel(unsigned x, unsigned y) const = 0;
/*! Returns the height of the complete image */
inline unsigned height() const
{
return _height;
}
/*! Sets the array.
* \param array
* The array containing the values we wish to store.
* Its size is sw*sh.
* \param width
* The width of the complete image
* \param height
* The height of the complete image
* \param sw
* The width of the rectangle that will actually
* be stored.
* \param sh
* The height of the rectangle that will actually
* be stored.
* \param ox
* The x-abscissa of the origin of the rectangle that will actually
* be stored.
* \param oy
* The x-abscissa of the origin of the rectangle that will actually
* be stored.
* \param copy
* If true, the array is copied, otherwise the pointer is
* copied
*/
virtual void setArray(float* array, unsigned width, unsigned height, unsigned sw, unsigned sh, unsigned x, unsigned y, bool copy = true) = 0;
/*! Returns the array containing the pixels values.
* Its size is sw*sh, i.e. potentially a smaller
* rectangular part of the complete image.
*/
virtual float * getArray() = 0;
/*! Returns the grey value for pixel x,y */
virtual float pixel(unsigned x, unsigned y) const = 0;
protected:
/*! Sets the array.
* \param array
* The array containing the values we wish to store.
* Its size is sw*sh.
* \param width
* The width of the complete image
* \param height
* The height of the complete image
* \param sw
* The width of the rectangle that will actually be stored.
* \param sh
* The height of the rectangle that will actually be stored.
* \param ox
* The x-abscissa of the origin of the rectangle that will actually be stored.
* \param oy
* The x-abscissa of the origin of the rectangle that will actually be stored.
* \param copy
* If true, the array is copied, otherwise the pointer is copied
*/
virtual void setArray(float *array, unsigned width, unsigned height, unsigned sw, unsigned sh,
unsigned x, unsigned y, bool copy = true) = 0;
unsigned _width;
unsigned _height;
unsigned _storedWidth;
unsigned _storedHeight;
unsigned _Ox; // origin of the stored part
unsigned _Oy; // origin of the stored part
/*! Returns the array containing the pixels values.
* Its size is sw*sh, i.e. potentially a smaller rectangular part of the complete image.
*/
virtual float *getArray() = 0;
protected:
unsigned _width;
unsigned _height;
unsigned _storedWidth;
unsigned _storedHeight;
unsigned _Ox; // origin of the stored part
unsigned _Oy; // origin of the stored part
};
@ -180,114 +179,130 @@ class FrsImage
// RGBImage
//
///////////////////////////////////////////////////////////////////////////////
class RGBImage : public FrsImage
{
public:
public:
RGBImage() : FrsImage()
{
_rgb = 0;
}
RGBImage() : FrsImage() {
_rgb = 0;
}
RGBImage(const RGBImage& brother) : FrsImage(brother)
{
_rgb = new float[3 * _storedWidth * _storedHeight];
memcpy(_rgb, brother._rgb, 3 * _storedWidth * _storedHeight * sizeof(float));
}
RGBImage(const RGBImage& brother) : FrsImage(brother) {
_rgb = new float[3 * _storedWidth * _storedHeight];
memcpy(_rgb, brother._rgb, 3 * _storedWidth * _storedHeight * sizeof(float));
}
RGBImage(unsigned w, unsigned h) : FrsImage(w, h)
{
_rgb = new float[3 * _width * _height];
}
RGBImage(unsigned w, unsigned h) : FrsImage(w, h) {
_rgb = new float[3 * _width * _height];
}
RGBImage(float *rgb, unsigned w, unsigned h) : FrsImage(w, h)
{
_rgb = new float[3 * _width * _height];
memcpy(_rgb, rgb, 3 * _width * _height * sizeof(float));
}
RGBImage(float* rgb, unsigned w, unsigned h) : FrsImage(w, h) {
_rgb = new float[3 * _width * _height];
memcpy(_rgb, rgb, 3 * _width * _height * sizeof(float));
}
/*! Builds an RGB partial image from the useful part buffer.
* \param rgb
* The array of size 3*sw*sh containing the RGB values
* of the sw*sh pixels we need to stored.
* These sw*sh pixels constitute a rectangular part of
* a bigger RGB image containing w*h pixels.
* \param w
* The width of the complete image
* \param h
* The height of the complete image
* \param sw
* The width of the part of the image we want to store and work on
* \param sh
* The height of the part of the image we want to store and work on
*/
RGBImage(float* rgb, unsigned w, unsigned h, unsigned sw, unsigned sh, unsigned ox, unsigned oy) : FrsImage(w, h, sw, sh, ox, oy) {
_rgb = new float[3 * _storedWidth * _storedHeight];
memcpy(_rgb, rgb, 3 * _storedWidth * _storedHeight * sizeof(float));
}
/*! Builds an RGB partial image from the useful part buffer.
* \param rgb
* The array of size 3*sw*sh containing the RGB values of the sw*sh pixels we need to stored.
* These sw*sh pixels constitute a rectangular part of a bigger RGB image containing w*h pixels.
* \param w
* The width of the complete image
* \param h
* The height of the complete image
* \param sw
* The width of the part of the image we want to store and work on
* \param sh
* The height of the part of the image we want to store and work on
*/
RGBImage(float *rgb, unsigned w, unsigned h, unsigned sw, unsigned sh, unsigned ox, unsigned oy)
: FrsImage(w, h, sw, sh, ox, oy)
{
_rgb = new float[3 * _storedWidth * _storedHeight];
memcpy(_rgb, rgb, 3 * _storedWidth * _storedHeight * sizeof(float));
}
RGBImage& operator=(const RGBImage& brother) {
dynamic_cast<FrsImage&>(*this) = brother;
_rgb = new float[3 * _storedWidth * _storedHeight];
memcpy(_rgb, brother._rgb, 3 * _storedWidth * _storedHeight * sizeof(float));
return* this;
}
RGBImage& operator=(const RGBImage& brother)
{
dynamic_cast<FrsImage&>(*this) = brother;
_rgb = new float[3 * _storedWidth * _storedHeight];
memcpy(_rgb, brother._rgb, 3 * _storedWidth * _storedHeight * sizeof(float));
return *this;
}
virtual ~RGBImage() {
if(_rgb)
delete[] _rgb;
}
virtual ~RGBImage()
{
if(_rgb)
delete[] _rgb;
}
inline float getR(unsigned x, unsigned y) const {
return _rgb[3 * (y-_Oy) * _storedWidth + (x-_Ox) * 3];
}
inline float getR(unsigned x, unsigned y) const
{
return _rgb[3 * (y - _Oy) * _storedWidth + (x - _Ox) * 3];
}
inline float getG(unsigned x, unsigned y) const {
return _rgb[3 * (y-_Oy) * _storedWidth + (x-_Ox) * 3 + 1];
}
inline float getG(unsigned x, unsigned y) const
{
return _rgb[3 * (y - _Oy) * _storedWidth + (x - _Ox) * 3 + 1];
}
inline float getB(unsigned x, unsigned y) const {
return _rgb[3 * (y-_Oy) * _storedWidth + (x-_Ox) * 3 + 2];
}
inline float getB(unsigned x, unsigned y) const
{
return _rgb[3 * (y - _Oy) * _storedWidth + (x - _Ox) * 3 + 2];
}
virtual void setPixel(unsigned x, unsigned y, float r, float g, float b){
float * tmp = &(_rgb[3 * (y-_Oy) * _storedWidth + (x-_Ox) * 3]);
*tmp = r;++tmp;
*tmp = g;++tmp;
*tmp = b;
}
virtual void setPixel(unsigned x, unsigned y, float r, float g, float b)
{
float *tmp = &(_rgb[3 * (y - _Oy) * _storedWidth + (x - _Ox) * 3]);
*tmp = r;
tmp++;
*tmp = g;
tmp++;
*tmp = b;
}
virtual float pixel(unsigned x, unsigned y) const {
float res = 0;
float* tmp = &(_rgb[3 * (y-_Oy) * _storedWidth + (x-_Ox) * 3]);
res += 11 * (*tmp++);
res += 16 * (*tmp++);
res += 5 * (*tmp);
return res / 32;
}
virtual float pixel(unsigned x, unsigned y) const
{
float res = 0.0f;
float *tmp = &(_rgb[3 * (y - _Oy) * _storedWidth + (x - _Ox) * 3]);
res += 11.0f * (*tmp);
tmp++;
res += 16.0f * (*tmp);
tmp++;
res += 5.0f * (*tmp);
return res / 32.0f;
}
/*! Sets the RGB array.
* copy
* If true, the array is copied, otherwise the pointer is
* copied
*/
virtual void setArray(float* rgb, unsigned width, unsigned height, unsigned sw, unsigned sh, unsigned x, unsigned y, bool copy = true) {
_width = width;
_height = height;
_storedWidth = sw;
_storedHeight = sh;
_Ox = x;
_Oy = y;
if(!copy) {
_rgb = rgb;
return;
}
memcpy(_rgb, rgb, 3 * _storedWidth * _storedHeight* sizeof(float));
}
/*! Sets the RGB array.
* copy
* If true, the array is copied, otherwise the pointer is copied
*/
virtual void setArray(float *rgb, unsigned width, unsigned height, unsigned sw, unsigned sh,
unsigned x, unsigned y, bool copy = true)
{
_width = width;
_height = height;
_storedWidth = sw;
_storedHeight = sh;
_Ox = x;
_Oy = y;
if (!copy) {
_rgb = rgb;
return;
}
virtual float * getArray() {return _rgb;}
memcpy(_rgb, rgb, 3 * _storedWidth * _storedHeight * sizeof(float));
}
protected:
virtual float *getArray()
{
return _rgb;
}
float* _rgb;
protected:
float *_rgb;
};
@ -298,92 +313,103 @@ class RGBImage : public FrsImage
class GrayImage : public FrsImage
{
public:
public:
GrayImage() : FrsImage()
{
_lvl = 0;
}
GrayImage() : FrsImage() {
_lvl = 0;
}
GrayImage(const GrayImage& brother) : FrsImage(brother)
{
_lvl = new float[_storedWidth * _storedHeight];
memcpy(_lvl, brother._lvl, _storedWidth * _storedHeight * sizeof(*_lvl));
}
GrayImage(const GrayImage& brother) : FrsImage(brother) {
_lvl = new float[_storedWidth*_storedHeight];
memcpy(_lvl, brother._lvl, _storedWidth*_storedHeight*sizeof(*_lvl));
}
/*! Builds an empty gray image */
GrayImage(unsigned w, unsigned h) : FrsImage(w, h)
{
_lvl = new float[_width * _height];
}
/*! Builds an empty gray image */
GrayImage(unsigned w, unsigned h) : FrsImage(w, h) {
_lvl = new float[_width*_height];
}
GrayImage(float *lvl, unsigned w, unsigned h) : FrsImage(w, h)
{
_lvl = new float[_width * _height];
memcpy(_lvl, lvl, _width * _height * sizeof(*_lvl));
}
GrayImage(float* lvl, unsigned w, unsigned h) : FrsImage(w, h) {
_lvl = new float[_width*_height];
memcpy(_lvl, lvl, _width*_height*sizeof(*_lvl));
}
/*! Builds a partial image from the useful part buffer.
* \param lvl
* The array of size sw*sh containing the gray values
* of the sw*sh pixels we need to stored.
* These sw*sh pixels constitute a rectangular part of
* a bigger gray image containing w*h pixels.
* \param w
* The width of the complete image
* \param h
* The height of the complete image
* \param sw
* The width of the part of the image we want to store and work on
* \param sh
* The height of the part of the image we want to store and work on
*/
GrayImage(float* lvl, unsigned w, unsigned h, unsigned sw, unsigned sh, unsigned ox, unsigned oy) : FrsImage(w, h, sw, sh, ox, oy) {
_lvl = new float[_storedWidth*_storedHeight];
memcpy(_lvl, lvl, _storedWidth*_storedHeight*sizeof(float));
}
/*! Builds a partial image from the useful part buffer.
* \param lvl
* The array of size sw*sh containing the gray values of the sw*sh pixels we need to stored.
* These sw*sh pixels constitute a rectangular part of a bigger gray image containing w*h pixels.
* \param w
* The width of the complete image
* \param h
* The height of the complete image
* \param sw
* The width of the part of the image we want to store and work on
* \param sh
* The height of the part of the image we want to store and work on
*/
GrayImage(float *lvl, unsigned w, unsigned h, unsigned sw, unsigned sh, unsigned ox, unsigned oy)
: FrsImage(w, h, sw, sh, ox, oy)
{
_lvl = new float[_storedWidth * _storedHeight];
memcpy(_lvl, lvl, _storedWidth * _storedHeight * sizeof(float));
}
GrayImage& operator=(const GrayImage& brother) {
dynamic_cast<FrsImage&>(*this) = brother;
_lvl = new float[_storedWidth * _storedHeight];
memcpy(_lvl, brother._lvl, _storedWidth * _storedHeight * sizeof(float));
return *this;
}
GrayImage& operator=(const GrayImage& brother)
{
dynamic_cast<FrsImage&>(*this) = brother;
_lvl = new float[_storedWidth * _storedHeight];
memcpy(_lvl, brother._lvl, _storedWidth * _storedHeight * sizeof(float));
return *this;
}
virtual ~GrayImage() {
if(_lvl)
delete[] _lvl;
}
virtual ~GrayImage()
{
if (_lvl)
delete[] _lvl;
}
inline void setPixel(unsigned x, unsigned y, float v){
_lvl[(y-_Oy) * _storedWidth+ (x-_Ox)] = v;
}
inline void setPixel(unsigned x, unsigned y, float v)
{
_lvl[(y - _Oy) * _storedWidth + (x - _Ox)] = v;
}
inline float pixel(unsigned x, unsigned y) const {
return _lvl[(y-_Oy) * _storedWidth+ (x-_Ox)];
}
inline float pixel(unsigned x, unsigned y) const
{
return _lvl[(y - _Oy) * _storedWidth + (x - _Ox)];
}
/*! Sets the array.
* copy
* If true, the array is copie, otherwise the pounsigneder is
* copied
*/
void setArray(float *lvl, unsigned width, unsigned height, unsigned sw, unsigned sh, unsigned x, unsigned y, bool copy = true) {
_width = width;
_height = height;
_storedWidth = sw;
_storedHeight = sh;
_Ox = x;
_Oy = y;
if(!copy) {
_lvl = lvl;
return;
}
memcpy(_lvl, lvl, _storedWidth * _storedHeight * sizeof(float));
}
/*! Returns the array containing the gray values. */
virtual float * getArray() {return _lvl;}
/*! Sets the array.
* copy
* If true, the array is copie, otherwise the pounsigneder is copied
*/
void setArray(float *lvl, unsigned width, unsigned height, unsigned sw, unsigned sh,
unsigned x, unsigned y, bool copy = true)
{
_width = width;
_height = height;
_storedWidth = sw;
_storedHeight = sh;
_Ox = x;
_Oy = y;
if (!copy) {
_lvl = lvl;
return;
}
protected:
memcpy(_lvl, lvl, _storedWidth * _storedHeight * sizeof(float));
}
float *_lvl;
/*! Returns the array containing the gray values. */
virtual float *getArray()
{
return _lvl;
}
protected:
float *_lvl;
};
#endif // IMAGE_H
#endif // __IMAGE_H__

334
source/blender/freestyle/intern/image/ImagePyramid.cpp
View File

@ -1,166 +1,192 @@
/*
* ***** 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/image/ImagePyramid.cpp
* \ingroup freestyle
* \brief Class to represent a pyramid of images
* \author Stephane Grabli
* \date 25/12/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.
//
///////////////////////////////////////////////////////////////////////////////
#include "ImagePyramid.h"
#include "Image.h"
#include "GaussianFilter.h"
#include <iostream>
#include "GaussianFilter.h"
#include "Image.h"
#include "ImagePyramid.h"
using namespace std;
//ImagePyramid::ImagePyramid(const GrayImage& level0, unsigned nbLevels){
// //BuildPyramid(level0,nbLevels);
//}
ImagePyramid::ImagePyramid(const ImagePyramid& iBrother){
if(!_levels.empty()){
for(vector<GrayImage*>::iterator im=_levels.begin(), imend=_levels.end();
im!=imend;
++im){
_levels.push_back(new GrayImage(**im));
}
}
}
ImagePyramid::~ImagePyramid(){
if(!_levels.empty()){
for(vector<GrayImage*>::iterator im=_levels.begin(), imend=_levels.end();
im!=imend;
++im){
delete (*im);
}
_levels.clear();
}
}
GrayImage * ImagePyramid::getLevel(int l){
return _levels[l];
}
float ImagePyramid::pixel(int x, int y, int level){
GrayImage *img = _levels[level];
if(0 == level){
return img->pixel(x,y);
}
unsigned int i = 1<<level;
unsigned int sx = x>>level;
unsigned int sy = y>>level;
if(sx >= img->width())
sx = img->width()-1;
if(sy >= img->height())
sy = img->height()-1;
// bilinear interpolation
float A = i*(sx+1)-x;
float B = x-i*sx;
float C = i*(sy+1)-y;
float D = y-i*sy;
float P1(0), P2(0);
P1 = A*img->pixel(sx,sy);
if(sx < img->width()-1){
if(x%i != 0)
P1 += B*img->pixel(sx+1,sy);
}else{
P1 += B*img->pixel(sx,sy);
}
if(sy<img->height()-1){
if(y%i != 0){
P2 = A*img->pixel(sx,sy+1);
if(sx < img->width()-1){
if(x%i != 0)
P2 += B*img->pixel(sx+1,sy+1);
}else{
P2 += B*img->pixel(sx,sy+1);
}
}
}else{
P2 = P1;
}
return (1.f/(float)(1<<2*level))*(C*P1 + D*P2);
}
int ImagePyramid::width(int level){
return _levels[level]->width();
}
int ImagePyramid::height(int level){
return _levels[level]->height();
}
GaussianPyramid::GaussianPyramid(const GrayImage& level0, unsigned nbLevels, float iSigma)
: ImagePyramid()
#if 0
ImagePyramid::ImagePyramid(const GrayImage& level0, unsigned nbLevels)
{
_sigma = iSigma;
BuildPyramid(level0,nbLevels);
}
GaussianPyramid::GaussianPyramid(GrayImage* level0, unsigned nbLevels, float iSigma)
: ImagePyramid()
BuildPyramid(level0,nbLevels);
}
#endif
ImagePyramid::ImagePyramid(const ImagePyramid& iBrother)
{
_sigma = iSigma;
BuildPyramid(level0,nbLevels);
if (!_levels.empty()) {
for (vector<GrayImage*>::iterator im = _levels.begin(), imend = _levels.end(); im != imend; ++im) {
_levels.push_back(new GrayImage(**im));
}
}
}
GaussianPyramid::GaussianPyramid(const GaussianPyramid& iBrother)
: ImagePyramid(iBrother){
_sigma = iBrother._sigma;
}
void GaussianPyramid::BuildPyramid(const GrayImage& level0, unsigned nbLevels){
GrayImage *pLevel = new GrayImage(level0);
BuildPyramid(pLevel, nbLevels);
ImagePyramid::~ImagePyramid()
{
if (!_levels.empty()) {
for (vector<GrayImage*>::iterator im = _levels.begin(), imend = _levels.end(); im != imend; ++im) {
delete (*im);
}
_levels.clear();
}
}
void GaussianPyramid::BuildPyramid(GrayImage* level0, unsigned nbLevels){
GrayImage *pLevel = level0;
_levels.push_back(pLevel);
GaussianFilter gf(_sigma);
// build the nbLevels:
unsigned w = pLevel->width();
unsigned h = pLevel->height();
if(nbLevels!=0)
{
for(unsigned i=0; i<nbLevels; ++i){ //soc
w = pLevel->width()>>1;
h = pLevel->height()>>1;
GrayImage *img = new GrayImage(w,h);
for(unsigned y=0; y<h; ++y){
for(unsigned x=0; x<w; ++x){
float v = gf.getSmoothedPixel<GrayImage>(pLevel, 2*x,2*y);
img->setPixel(x,y,v);
}
}
_levels.push_back(img);
pLevel = img;
}
}else{
while((w>1) && (h>1)){
w = pLevel->width()>>1;
h = pLevel->height()>>1;
GrayImage *img = new GrayImage(w,h);
for(unsigned y=0; y<h; ++y){
for(unsigned x=0; x<w; ++x){
float v = gf.getSmoothedPixel<GrayImage>(pLevel, 2*x,2*y);
img->setPixel(x,y,v);
}
}
_levels.push_back(img);
pLevel = img;
}
}
GrayImage * ImagePyramid::getLevel(int l)
{
return _levels[l];
}
float ImagePyramid::pixel(int x, int y, int level)
{
GrayImage *img = _levels[level];
if (0 == level) {
return img->pixel(x, y);
}
unsigned int i = 1 << level;
unsigned int sx = x >> level;
unsigned int sy = y >> level;
if (sx >= img->width())
sx = img->width() - 1;
if (sy >= img->height())
sy = img->height() - 1;
// bilinear interpolation
float A = i * (sx + 1) - x;
float B = x - i * sx;
float C = i * (sy + 1) - y;
float D = y - i * sy;
float P1(0), P2(0);
P1 = A * img->pixel(sx, sy);
if (sx < img->width() - 1) {
if (x % i != 0)
P1 += B * img->pixel(sx + 1, sy);
}
else {
P1 += B * img->pixel(sx, sy);
}
if (sy < img->height() - 1) {
if (y % i != 0) {
P2 = A * img->pixel(sx, sy + 1);
if (sx < img->width() - 1) {
if (x % i != 0)
P2 += B * img->pixel(sx + 1, sy + 1);
}
else {
P2 += B * img->pixel(sx, sy + 1);
}
}
}
else {
P2 = P1;
}
return (1.0f / (float)(1 << (2 * level))) * (C * P1 + D * P2);
}
int ImagePyramid::width(int level)
{
return _levels[level]->width();
}
int ImagePyramid::height(int level)
{
return _levels[level]->height();
}
GaussianPyramid::GaussianPyramid(const GrayImage& level0, unsigned nbLevels, float iSigma) : ImagePyramid()
{
_sigma = iSigma;
BuildPyramid(level0, nbLevels);
}
GaussianPyramid::GaussianPyramid(GrayImage* level0, unsigned nbLevels, float iSigma) : ImagePyramid()
{
_sigma = iSigma;
BuildPyramid(level0, nbLevels);
}
GaussianPyramid::GaussianPyramid(const GaussianPyramid& iBrother) : ImagePyramid(iBrother)
{
_sigma = iBrother._sigma;
}
void GaussianPyramid::BuildPyramid(const GrayImage& level0, unsigned nbLevels)
{
GrayImage *pLevel = new GrayImage(level0);
BuildPyramid(pLevel, nbLevels);
}
void GaussianPyramid::BuildPyramid(GrayImage* level0, unsigned nbLevels)
{
GrayImage *pLevel = level0;
_levels.push_back(pLevel);
GaussianFilter gf(_sigma);
// build the nbLevels:
unsigned w = pLevel->width();
unsigned h = pLevel->height();
if (nbLevels != 0) {
for (unsigned int i = 0; i < nbLevels; ++i) { //soc
w = pLevel->width() >> 1;
h = pLevel->height() >> 1;
GrayImage *img = new GrayImage(w, h);
for (unsigned int y = 0; y < h; ++y) {
for (unsigned int x = 0; x < w; ++x) {
float v = gf.getSmoothedPixel<GrayImage>(pLevel, 2 * x, 2 * y);
img->setPixel(x, y, v);
}
}
_levels.push_back(img);
pLevel = img;
}
}
else {
while ((w > 1) && (h > 1)) {
w = pLevel->width() >> 1;
h = pLevel->height() >> 1;
GrayImage *img = new GrayImage(w, h);
for (unsigned int y = 0; y < h; ++y) {
for (unsigned int x = 0; x < w; ++x) {
float v = gf.getSmoothedPixel<GrayImage>(pLevel, 2 * x, 2 * y);
img->setPixel(x, y, v);
}
}
_levels.push_back(img);
pLevel = img;
}
}
}

180
source/blender/freestyle/intern/image/ImagePyramid.h
View File

@ -1,92 +1,116 @@
//
// Filename : ImagePyramid.h
// Author(s) : Stephane Grabli
// Purpose : Class to represent a pyramid of images
// Date of creation : 25/12/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 __IMAGEPYRAMID_H__
#define __IMAGEPYRAMID_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/image/ImagePyramid.h
* \ingroup freestyle
* \brief Class to represent a pyramid of images
* \author Stephane Grabli
* \date 25/12/2003
*/
#ifndef IMAGEPYRAMID_H
# define IMAGEPYRAMID_H
#include "../system/FreestyleConfig.h"
#include <vector>
class GrayImage;
class LIB_IMAGE_EXPORT ImagePyramid{
protected:
std::vector<GrayImage*> _levels;
public:
ImagePyramid(){}
ImagePyramid(const ImagePyramid& iBrother);
//ImagePyramid(const GrayImage& level0, unsigned nbLevels);
virtual ~ImagePyramid();
#include "../system/FreestyleConfig.h"
/*! Builds the pyramid.
* must be overloaded by inherited classes.
* if nbLevels==0, the complete pyramid is built
*/
virtual void BuildPyramid(const GrayImage& level0, unsigned nbLevels) = 0;
/*! Builds a pyramid without copying the base level */
virtual void BuildPyramid(GrayImage* level0, unsigned nbLevels) = 0;
virtual GrayImage * getLevel(int l);
/*! Returns the pixel x,y using bilinear interpolation.
* \param x
* the abscissa specified in the finest level coordinate system
* \param y
* the ordinate specified in the finest level coordinate system
* \param level
* the level from which we want the pixel to be evaluated
*/
virtual float pixel(int x, int y, int level=0);
/*! Returns the width of the level-th level image */
virtual int width(int level=0);
/*! Returns the height of the level-th level image */
virtual int height(int level=0);
/*! Returns the number of levels in the pyramid */
inline int getNumberOfLevels() const { return _levels.size();}
};
class GrayImage;
class LIB_IMAGE_EXPORT ImagePyramid
{
protected:
std::vector<GrayImage*> _levels;
public:
ImagePyramid(){}
ImagePyramid(const ImagePyramid& iBrother);
//ImagePyramid(const GrayImage& level0, unsigned nbLevels);
virtual ~ImagePyramid();
/*! Builds the pyramid.
* must be overloaded by inherited classes.
* if nbLevels==0, the complete pyramid is built
*/
virtual void BuildPyramid(const GrayImage& level0, unsigned nbLevels) = 0;
/*! Builds a pyramid without copying the base level */
virtual void BuildPyramid(GrayImage* level0, unsigned nbLevels) = 0;
virtual GrayImage * getLevel(int l);
/*! Returns the pixel x,y using bilinear interpolation.
* \param x
* the abscissa specified in the finest level coordinate system
* \param y
* the ordinate specified in the finest level coordinate system
* \param level
* the level from which we want the pixel to be evaluated
*/
virtual float pixel(int x, int y, int level=0);
/*! Returns the width of the level-th level image */
virtual int width(int level=0);
/*! Returns the height of the level-th level image */
virtual int height(int level=0);
/*! Returns the number of levels in the pyramid */
inline int getNumberOfLevels() const
{
return _levels.size();
}
};
class LIB_IMAGE_EXPORT GaussianPyramid : public ImagePyramid
{
protected:
float _sigma;
float _sigma;
public:
GaussianPyramid(float iSigma=1.f) : ImagePyramid() {_sigma=iSigma;}
GaussianPyramid(const GrayImage& level0, unsigned nbLevels, float iSigma=1.f);
GaussianPyramid(GrayImage* level0, unsigned nbLevels, float iSigma=1.f);
GaussianPyramid(const GaussianPyramid& iBrother);
virtual ~GaussianPyramid(){}
GaussianPyramid(float iSigma=1.f) : ImagePyramid()
{
_sigma = iSigma;
}
virtual void BuildPyramid(const GrayImage& level0, unsigned nbLevels);
virtual void BuildPyramid(GrayImage* level0, unsigned nbLevels);
/* accessors */
inline float getSigma() const {return _sigma;}
/* modifiers */
GaussianPyramid(const GrayImage& level0, unsigned nbLevels, float iSigma=1.0f);
GaussianPyramid(GrayImage* level0, unsigned nbLevels, float iSigma=1.0f);
GaussianPyramid(const GaussianPyramid& iBrother);
virtual ~GaussianPyramid() {}
virtual void BuildPyramid(const GrayImage& level0, unsigned nbLevels);
virtual void BuildPyramid(GrayImage* level0, unsigned nbLevels);
/* accessors */
inline float getSigma() const
{
return _sigma;
}
/* modifiers */
};
#endif // IMAGEPYRAMID_H
#endif // __IMAGEPYRAMID_H__