Skip to content
GitLab
Projects
Groups
Snippets
/
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in
Toggle navigation
Menu
Open sidebar
David Cazier
CGoGN
Commits
fef11c8a
Commit
fef11c8a
authored
Jun 12, 2012
by
Sylvain Thery
Browse files
add histogram algo & qt drawer
parent
01ff9703
Changes
5
Hide whitespace changes
Inline
Side-by-side
include/Algo/Histogram/histogram.h
0 → 100644
View file @
fef11c8a
/*******************************************************************************
* CGoGN: Combinatorial and Geometric modeling with Generic N-dimensional Maps *
* version 0.1 *
* Copyright (C) 2009-2012, IGG Team, LSIIT, University of Strasbourg *
* *
* This library is free software; you can redistribute it and/or modify it *
* under the terms of the GNU Lesser General Public License as published by the *
* Free Software Foundation; either version 2.1 of the License, or (at your *
* option) any later version. *
* *
* This library 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 Lesser General Public License *
* for more details. *
* *
* You should have received a copy of the GNU Lesser General Public License *
* along with this library; if not, write to the Free Software Foundation, *
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. *
* *
* Web site: http://cgogn.unistra.fr/ *
* Contact information: cgogn@unistra.fr *
* *
*******************************************************************************/
#ifndef __HISTOGRAM__
#define __HISTOGRAM__
#include
"Topology/generic/attributeHandler.h"
#include
"Geometry/vector_gen.h"
#include
"Utils/colorMaps.h"
#include
"Utils/vbo.h"
namespace
CGoGN
{
namespace
Algo
{
namespace
Histogram
{
class
HistoColorMap
{
protected:
double
m_min
;
double
m_max
;
double
m_w
;
unsigned
int
m_nb
;
public:
virtual
~
HistoColorMap
()
{}
/// set min value (for update from Histogram)
void
setMin
(
double
m
)
{
m_min
=
m
;
m_w
=
(
m_max
-
m_min
)
/
double
(
m_nb
);}
/// set max value (for update from Histogram)
void
setMax
(
double
m
)
{
m_max
=
m
;
m_w
=
(
m_max
-
m_min
)
/
double
(
m_nb
);}
/// set nb value (for update from Histogram)
void
setNb
(
unsigned
int
n
)
{
m_nb
=
n
;
m_w
=
(
m_max
-
m_min
)
/
double
(
m_nb
);}
/**
* get color from param: To implement (with call to colormap functions for examples)
*/
virtual
Geom
::
Vec3f
color
(
double
v
)
const
=
0
;
/**
* get color from index (can be overload)
* compute a [0,1[ value from an index [0,nb[
* and call color with it
* Used by Histogram::colorize && Qt::DrawHistogram
*/
virtual
Geom
::
Vec3f
colorIndex
(
unsigned
int
i
)
const
{
double
v
=
double
(
i
)
/
double
(
m_nb
-
1
)
+
double
(
1
)
/
double
(
m_nb
+
m_nb
);
return
color
(
v
);
}
};
/**
* inherits this class by:
* - add xxAttribute& in data (& constructor)
* - overload begin/end/next/nbElements (by calling xxxAttribute.yyy)
* - overload operator [] to return the [i] converted in double with necessary computations.
*/
class
AttributeConvertGen
{
public:
virtual
unsigned
int
begin
()
const
=
0
;
virtual
unsigned
int
end
()
const
=
0
;
virtual
void
next
(
unsigned
int
&
i
)
const
=
0
;
virtual
unsigned
int
nbElements
()
const
=
0
;
virtual
double
operator
[](
unsigned
int
i
)
const
=
0
;
virtual
~
AttributeConvertGen
()
{}
};
/**
* Helper class templated by Attribute
* Avoid the writing of begin/end/next/nbElements
*/
template
<
typename
ATT
>
class
AttributeConvert
:
public
AttributeConvertGen
{
protected:
ATT
&
attrib
;
public:
AttributeConvert
(
ATT
&
att
)
:
attrib
(
att
)
{}
virtual
unsigned
int
begin
()
const
{
return
attrib
.
begin
();}
virtual
unsigned
int
end
()
const
{
return
attrib
.
end
();}
virtual
void
next
(
unsigned
int
&
i
)
const
{
attrib
.
next
(
i
);}
virtual
unsigned
int
nbElements
()
const
{
return
attrib
.
nbElements
();}
virtual
double
operator
[](
unsigned
int
i
)
const
=
0
;
virtual
~
AttributeConvert
()
{}
};
/**
* Histogram class
* T must have operators -, / ,< ,>
*/
class
Histogram
{
// std::vector<double> m_data;
std
::
vector
<
std
::
pair
<
double
,
unsigned
int
>
>
m_dataIdx
;
/// number of classes in attribute
unsigned
int
m_nbclasses
;
/// vector of population
std
::
vector
<
unsigned
int
>
m_populations
;
/// vector of intervals of quantilles
std
::
vector
<
double
>
m_interv
;
/// vector of population for quantilles
std
::
vector
<
double
>
m_pop_quantilles
;
/// min value
double
m_min
;
/// max value
double
m_max
;
/// interval width (in regular case)
double
m_interWidth
;
/// max number of population in a class
unsigned
int
m_nbMin
;
/// max values in histo population
unsigned
int
m_maxBar
;
/// max value in quantille population
double
m_maxQBar
;
HistoColorMap
&
m_hcolmap
;
bool
m_sorted
;
/// get data
double
data
(
unsigned
int
i
)
const
;
/// get idx of data in attribute
unsigned
int
idx
(
unsigned
int
i
)
const
;
// comparison function for sorting data
static
bool
dataComp
(
const
std
::
pair
<
double
,
unsigned
int
>&
a
,
const
std
::
pair
<
double
,
unsigned
int
>&
b
);
public:
/**
* create an histogram from attribute handler
*/
Histogram
(
HistoColorMap
&
hcm
);
/**
* init data
* @param conv a attribute convertor
*/
void
initDataConvert
(
const
AttributeConvertGen
&
conv
);
/**
* init data
* @param attr the attribute to copy from
* @param sortForQuantilles sort data vector for quantille generation
*/
template
<
typename
ATTR
>
void
initData
(
const
ATTR
&
attr
);
/**
* get min value of attribute (perhaps modified by user)
*/
double
getMin
()
const
;
/**
* get max value of attribute (perhaps modified by user)
*/
double
getMax
()
const
;
/**
* get real min value of attribute
*/
double
getQMin
()
const
;
/**
* get real max value of attribute
*/
double
getQMax
()
const
;
/**
* set min value of attribute
*/
void
setMin
(
double
m
);
/**
* set max value of attribute
*/
void
setMax
(
double
m
);
/**
* get max population value of all bars of histo
*/
unsigned
int
getMaxBar
()
const
;
/**
* get max population value of all bars of quantilles
*/
double
getMaxQBar
()
const
;
/**
* modify min/max values to center Histogram on zero if necessary
*/
void
centerOnZero
();
/**
* compute the histogram with given numbre of classes
*/
void
populateHisto
(
unsigned
int
nbclasses
=
0
);
/**
* compute the histogram with given number of classes
*/
void
populateQuantilles
(
unsigned
int
nbclasses
=
10
);
/**
* which class belong a value
*/
unsigned
int
whichClass
(
double
val
)
const
;
/**
* which class belong a value
*/
unsigned
int
whichQuantille
(
double
val
)
const
;
/**
* fill a color attribute
* @param colors attribute to fill
*/
template
<
typename
ATTC
>
void
histoColorize
(
ATTC
&
colors
);
/**
* colorize the VBO (RGB)
* @warning GL context must be accessible
* @param vbo the vbo to fill with colors
*/
void
histoColorizeVBO
(
Utils
::
VBO
&
vbo
);
/**
* fill a color attribute
* @param colors attribute to fill
* @param tc table of color
*/
template
<
typename
ATTC
>
void
quantillesColorize
(
ATTC
&
colors
,
const
std
::
vector
<
Geom
::
Vec3f
>&
tc
);
/**
* fill a color attribute
* @param colors attribute to fill
* @param func colormap function (Geom::Vec3f func(float x)
*/
template
<
typename
ATTC
,
typename
COLORMAP
>
void
quantillesColorizeFunc
(
ATTC
&
colors
,
COLORMAP
func
);
/**
* get the vector of class population
*/
const
std
::
vector
<
unsigned
int
>&
getPopulation
()
const
;
/**
* get the vector of height of quantilles
*/
const
std
::
vector
<
double
>&
getQuantillesHeights
()
const
;
/**
* get the vector of intervals bounaries for quantilles
*/
const
std
::
vector
<
double
>&
getQuantillesIntervals
()
const
;
/**
* get the colorMap
*/
const
HistoColorMap
&
colorMap
()
const
;
};
}
}
}
#include
"Algo/Histogram/histogram.hpp"
#endif
include/Algo/Histogram/histogram.hpp
0 → 100644
View file @
fef11c8a
/*******************************************************************************
* CGoGN: Combinatorial and Geometric modeling with Generic N-dimensional Maps *
* version 0.1 *
* Copyright (C) 2009-2012, IGG Team, LSIIT, University of Strasbourg *
* *
* This library is free software; you can redistribute it and/or modify it *
* under the terms of the GNU Lesser General Public License as published by the *
* Free Software Foundation; either version 2.1 of the License, or (at your *
* option) any later version. *
* *
* This library 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 Lesser General Public License *
* for more details. *
* *
* You should have received a copy of the GNU Lesser General Public License *
* along with this library; if not, write to the Free Software Foundation, *
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. *
* *
* Web site: http://cgogn.unistra.fr/ *
* Contact information: cgogn@unistra.fr *
* *
*******************************************************************************/
// forward
namespace
CGoGN
{
namespace
Algo
{
namespace
Histogram
{
inline
Histogram
::
Histogram
(
HistoColorMap
&
hcm
)
:
m_hcolmap
(
hcm
),
m_sorted
(
false
)
{
}
inline
const
std
::
vector
<
unsigned
int
>&
Histogram
::
getPopulation
()
const
{
return
m_populations
;
}
inline
const
std
::
vector
<
double
>&
Histogram
::
getQuantillesHeights
()
const
{
return
m_pop_quantilles
;
}
inline
const
std
::
vector
<
double
>&
Histogram
::
getQuantillesIntervals
()
const
{
return
m_interv
;
}
inline
const
HistoColorMap
&
Histogram
::
colorMap
()
const
{
return
m_hcolmap
;
}
inline
double
Histogram
::
getMin
()
const
{
return
m_min
;
}
inline
double
Histogram
::
getMax
()
const
{
return
m_max
;
}
inline
double
Histogram
::
getQMin
()
const
{
return
m_dataIdx
.
front
().
first
;
}
inline
double
Histogram
::
getQMax
()
const
{
return
m_dataIdx
.
back
().
first
;
}
inline
unsigned
int
Histogram
::
getMaxBar
()
const
{
return
m_maxBar
;
}
inline
double
Histogram
::
getMaxQBar
()
const
{
return
m_maxQBar
;
}
inline
void
Histogram
::
setMin
(
double
m
)
{
m_min
=
m
;
m_hcolmap
.
setMin
(
m
);
}
inline
void
Histogram
::
setMax
(
double
m
)
{
m_max
=
m
;
m_hcolmap
.
setMax
(
m
);
}
inline
void
Histogram
::
centerOnZero
()
{
if
((
m_min
<
0.0
)
&&
(
m_max
>
0.0
))
{
if
((
-
m_min
)
>
m_max
)
m_max
=
-
m_min
;
else
m_min
=
-
m_max
;
}
}
template
<
typename
ATTR
>
inline
void
Histogram
::
initData
(
const
ATTR
&
attr
)
{
unsigned
int
beg
=
attr
.
begin
();
m_min
=
attr
[
beg
];
m_max
=
m_min
;
m_dataIdx
.
reserve
(
attr
.
nbElements
());
for
(
unsigned
int
i
=
beg
;
i
!=
attr
.
end
();
attr
.
next
(
i
))
{
double
val
=
attr
[
i
];
m_dataIdx
.
push_back
(
std
::
make_pair
(
val
,
i
));
if
(
val
<
m_min
)
m_min
=
val
;
if
(
val
>
m_max
)
m_max
=
val
;
}
m_hcolmap
.
setMin
(
m_min
);
m_hcolmap
.
setMax
(
m_max
);
}
inline
unsigned
int
Histogram
::
whichClass
(
double
val
)
const
{
if
(
val
==
m_max
)
return
m_populations
.
size
()
-
1
;
double
x
=
(
val
-
m_min
)
/
m_interWidth
;
if
((
x
<
0
)
||
(
val
>=
m_max
))
return
-
1
;
return
(
unsigned
int
)(
x
);
}
inline
unsigned
int
Histogram
::
whichQuantille
(
double
val
)
const
{
unsigned
int
i
=
1
;
while
(
val
>
m_interv
[
i
])
++
i
;
return
i
-
1
;
}
template
<
typename
ATTC
>
void
Histogram
::
histoColorize
(
ATTC
&
colors
)
{
unsigned
int
nb
=
m_dataIdx
.
size
();
for
(
unsigned
int
i
=
0
;
i
<
nb
;
++
i
)
{
unsigned
int
j
=
idx
(
i
);
unsigned
int
c
=
whichClass
(
data
(
i
));
if
(
c
!=
0xffffffff
)
colors
[
j
]
=
m_hcolmap
.
colorIndex
(
c
);
}
}
template
<
typename
ATTC
>
void
Histogram
::
quantillesColorize
(
ATTC
&
colors
,
const
std
::
vector
<
Geom
::
Vec3f
>&
tc
)
{
unsigned
int
nb
=
m_dataIdx
.
size
();
unsigned
int
nbi
=
m_interv
.
size
()
-
1
;
assert
(
tc
.
size
()
>=
nbi
);
unsigned
int
i
=
0
;
unsigned
int
j
=
0
;
while
((
i
<
nb
)
&&
(
j
<
nbi
))
{
while
((
i
<
nb
)
&&
(
data
(
i
)
<=
m_interv
[
j
+
1
]))
colors
[
idx
(
i
++
)
]
=
tc
[
j
];
++
j
;
}
}
/// get data
inline
double
Histogram
::
data
(
unsigned
int
i
)
const
{
return
m_dataIdx
[
i
].
first
;
}
/// get idx of data in attribute
inline
unsigned
int
Histogram
::
idx
(
unsigned
int
i
)
const
{
return
m_dataIdx
[
i
].
second
;
}
// comparison function for sorting data
inline
bool
Histogram
::
dataComp
(
const
std
::
pair
<
double
,
unsigned
int
>&
a
,
const
std
::
pair
<
double
,
unsigned
int
>&
b
)
{
return
a
.
first
<
b
.
first
;
}
}
}
}
include/Utils/Qt/qthistodraw.h
0 → 100644
View file @
fef11c8a
/*******************************************************************************
* CGoGN: Combinatorial and Geometric modeling with Generic N-dimensional Maps *
* version 0.1 *
* Copyright (C) 2009-2012, IGG Team, LSIIT, University of Strasbourg *
* *
* This library is free software; you can redistribute it and/or modify it *
* under the terms of the GNU Lesser General Public License as published by the *
* Free Software Foundation; either version 2.1 of the License, or (at your *
* option) any later version. *
* *
* This library 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 Lesser General Public License *
* for more details. *
* *
* You should have received a copy of the GNU Lesser General Public License *
* along with this library; if not, write to the Free Software Foundation, *
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. *
* *
* Web site: http://cgogn.unistra.fr/ *
* Contact information: cgogn@unistra.fr *
* *
*******************************************************************************/
#ifndef __QT_HISTO_DRAW__
#define __QT_HISTO_DRAW__
#include
<QWidget>
#include
<QPainter>
#include
<QMouseEvent>
#include
"Utils/Qt/qtpopup.h"
#include
"Algo/Histogram/histogram.h"
namespace
CGoGN
{
namespace
Utils
{
namespace
QT
{
class
RenderHistogram
:
public
QWidget
{
Q_OBJECT
static
const
int
m_frameWidth
=
10
;
const
Algo
::
Histogram
::
Histogram
&
m_histo
;
std
::
vector
<
Geom
::
Vec3f
>
m_qcolors
;
unsigned
int
m_max
;
int
m_h
;
int
m_w
;
unsigned
int
m_l
;
std
::
vector
<
int
>
m_vals_ax_left
;
int
m_axl_nbd
;
bool
m_drawHisto
;
bool
m_drawQuantilles
;
bool
m_histoFront
;
float
m_opacity
;
bool
m_drawAxis
;