summaryrefslogtreecommitdiff
path: root/src/io/colormaps.hh
diff options
context:
space:
mode:
Diffstat (limited to 'src/io/colormaps.hh')
-rw-r--r--src/io/colormaps.hh432
1 files changed, 432 insertions, 0 deletions
diff --git a/src/io/colormaps.hh b/src/io/colormaps.hh
new file mode 100644
index 0000000..24cf98b
--- /dev/null
+++ b/src/io/colormaps.hh
@@ -0,0 +1,432 @@
+/* This file is part of the OpenLB library
+ *
+ * Copyright (C) 2006, 2007 Jonas Latt
+ * E-mail contact: info@openlb.net
+ * The most recent release of OpenLB can be downloaded at
+ * <http://www.openlb.net/>
+ *
+ * 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.
+*/
+
+#ifndef COLORMAPS_HH
+#define COLORMAPS_HH
+
+#include "colormaps.h"
+#include <cmath>
+
+namespace olb {
+
+namespace graphics {
+
+template <typename T>
+LinearFunction<T>::LinearFunction(T x1_, T x2_, T y1_, T y2_)
+ : x1(x1_), x2(x2_), y1(y1_), y2(y2_)
+{ }
+
+template <typename T>
+T LinearFunction<T>::operator() (T x) const
+{
+ return ( (y2-y1) * x + x2*y1-x1*y2 )/(x2-x1);
+}
+
+template <typename T>
+LinearFunction<T>* LinearFunction<T>::clone() const
+{
+ return new LinearFunction(*this);
+}
+
+template <typename T>
+PowerLawFunction<T>::PowerLawFunction(T x1_, T x2_, T y1_, T y2_, T b_)
+ : x1(std::pow(x1_,b_)), x2(std::pow(x2_,b_)), y1(y1_), y2(y2_), b(b_)
+{ }
+
+template <typename T>
+T PowerLawFunction<T>::operator() (T x) const
+{
+ return ( (y2-y1) * std::pow(x,b) + x2*y1-x1*y2 )/(x2-x1);
+}
+
+template <typename T>
+PowerLawFunction<T>* PowerLawFunction<T>::clone() const
+{
+ return new PowerLawFunction(*this);
+}
+
+
+template <typename T>
+PiecewiseFunction<T>::PiecewiseFunction(PiecewiseFunction<T> const& rhs)
+ : pieces(rhs.pieces),
+ functions(rhs.functions.size())
+{
+ for (unsigned iF=0; iF<functions.size(); ++iF) {
+ functions[iF] = rhs.functions[iF]->clone();
+ }
+}
+
+template <typename T>
+PiecewiseFunction<T>& PiecewiseFunction<T>::operator=(PiecewiseFunction<T> const& rhs)
+{
+ PiecewiseFunction<T>(rhs).swap(*this);
+ return *this;
+}
+
+template <typename T>
+PiecewiseFunction<T>::~PiecewiseFunction()
+{
+ for (unsigned iF=0; iF<functions.size(); ++iF) {
+ delete functions[iF];
+ }
+}
+
+template <typename T>
+void PiecewiseFunction<T>::swap(PiecewiseFunction<T>& rhs)
+{
+ pieces.swap(rhs.pieces);
+ functions.swap(rhs.functions);
+}
+
+template <typename T>
+void PiecewiseFunction<T>::addPiece(Piece<T> piece, ScalarFunction<T>* f)
+{
+ typename std::vector<Piece<T> >::iterator pieceIt = pieces.begin();
+ typename std::vector<ScalarFunction<T>*>::iterator fIt = functions.begin();
+ while (pieceIt != pieces.end() && piece.closedBegin >= pieceIt->closedBegin) {
+ ++pieceIt;
+ ++fIt;
+ }
+ pieces.insert(pieceIt, piece);
+ functions.insert(fIt, f);
+}
+
+template <typename T>
+T PiecewiseFunction<T>::operator() (T x) const
+{
+ if (pieces.empty() || x<pieces[0].closedBegin) {
+ return T();
+ }
+ unsigned iPiece=0;
+ while (iPiece != pieces.size() && x >= pieces[iPiece].openEnd) {
+ ++iPiece;
+ }
+ if (iPiece == pieces.size() || x < pieces[iPiece].closedBegin) {
+ return T();
+ }
+ return (*functions[iPiece])(x);
+}
+
+template <typename T>
+PiecewiseFunction<T>* PiecewiseFunction<T>::clone() const
+{
+ return new PiecewiseFunction(*this);
+}
+
+template <typename T>
+ColorMap<T>::ColorMap(PiecewiseFunction<T> const& red_,
+ PiecewiseFunction<T> const& green_,
+ PiecewiseFunction<T> const& blue_)
+ : red(red_), green(green_), blue(blue_)
+{ }
+
+template <typename T>
+rgb<T> ColorMap<T>::get(T x) const
+{
+ return rgb<T>( red(x), green(x), blue(x) );
+}
+
+namespace mapGenerators {
+
+template <typename T>
+PiecewiseFunction<T> generateEarthRed()
+{
+ T p0 = (T) 0.;
+ T p1 = (T) 3./8.;
+ T p2 = (T) 6./8.;
+ T p3 = (T) 1.;
+
+ PiecewiseFunction<T> earthRed;
+ earthRed.addPiece (Piece<T>(p0, p1), new PowerLawFunction<T>(p0, p1, (T)0., (T)0.8, (T)0.6) );
+ earthRed.addPiece (Piece<T>(p1, p2), new PowerLawFunction<T>(p1, p2, (T)0.8, (T)0.9, (T)0.9) );
+ earthRed.addPiece (Piece<T>(p2, p3), new PowerLawFunction<T>(p2, p3, (T)0.9, (T)1.0, (T)0.2) );
+
+ return earthRed;
+}
+
+template <typename T>
+PiecewiseFunction<T> generateEarthGreen()
+{
+ T p0 = (T) 0.;
+ T p1 = (T) 3./8.;
+ T p2 = (T) 6./8.;
+ T p3 = (T) 1.;
+
+ PiecewiseFunction<T> earthGreen;
+ earthGreen.addPiece (Piece<T>(p0, p1), new PowerLawFunction<T>(p0, p1, (T)0., (T)0.5, (T)0.6) );
+ earthGreen.addPiece (Piece<T>(p1, p2), new PowerLawFunction<T>(p1, p2, (T)0.5, (T)0.9, (T)0.2) );
+ earthGreen.addPiece (Piece<T>(p2, p3), new PowerLawFunction<T>(p2, p3, (T)0.9, (T)1.0, (T)0.2) );
+
+ return earthGreen;
+}
+
+template <typename T>
+PiecewiseFunction<T> generateEarthBlue()
+{
+ T p0 = (T) 0.;
+ T p1 = (T) 3./8.;
+ T p2 = (T) 6./8.;
+ T p3 = (T) 1.;
+
+ PiecewiseFunction<T> earthBlue;
+ earthBlue.addPiece (Piece<T>(p0, p1), new PowerLawFunction<T>(p0, p1, (T)0., (T)0.5, (T)0.6) );
+ earthBlue.addPiece (Piece<T>(p1, p2), new PowerLawFunction<T>(p1, p2, (T)0.5, (T)0.7, (T)0.2) );
+ earthBlue.addPiece (Piece<T>(p2, p3), new PowerLawFunction<T>(p2, p3, (T)0.7, (T)1.0, (T)0.2) );
+
+ return earthBlue;
+}
+
+template <typename T>
+PiecewiseFunction<T> generateWaterRed()
+{
+ T p0 = (T) 0.;
+ T p1 = (T) 3./8.;
+ T p2 = (T) 6./8.;
+ T p3 = (T) 1.;
+
+ PiecewiseFunction<T> waterRed;
+ waterRed.addPiece (Piece<T>(p0, p1), new PowerLawFunction<T>(p0, p1, (T)0., (T)0.5, (T)0.6) );
+ waterRed.addPiece (Piece<T>(p1, p2), new PowerLawFunction<T>(p1, p2, (T)0.5, (T)0.7, (T)0.2) );
+ waterRed.addPiece (Piece<T>(p2, p3), new PowerLawFunction<T>(p2, p3, (T)0.7, (T)1.0, (T)0.2) );
+
+ return waterRed;
+}
+
+template <typename T>
+PiecewiseFunction<T> generateWaterGreen()
+{
+ T p0 = (T) 0.;
+ T p1 = (T) 3./8.;
+ T p2 = (T) 6./8.;
+ T p3 = (T) 1.;
+
+ PiecewiseFunction<T> waterGreen;
+ waterGreen.addPiece (Piece<T>(p0, p1), new PowerLawFunction<T>(p0, p1, (T)0., (T)0.5, (T)0.6) );
+ waterGreen.addPiece (Piece<T>(p1, p2), new PowerLawFunction<T>(p1, p2, (T)0.5, (T)0.9, (T)0.2) );
+ waterGreen.addPiece (Piece<T>(p2, p3), new PowerLawFunction<T>(p2, p3, (T)0.9, (T)1.0, (T)0.2) );
+
+ return waterGreen;
+}
+
+template <typename T>
+PiecewiseFunction<T> generateWaterBlue()
+{
+ T p0 = (T) 0.;
+ T p1 = (T) 3./8.;
+ T p2 = (T) 6./8.;
+ T p3 = (T) 1.;
+
+ PiecewiseFunction<T> waterBlue;
+ waterBlue.addPiece (Piece<T>(p0, p1), new PowerLawFunction<T>(p0, p1, (T)0., (T)0.8, (T)0.6) );
+ waterBlue.addPiece (Piece<T>(p1, p2), new PowerLawFunction<T>(p1, p2, (T)0.8, (T)0.9, (T)0.9) );
+ waterBlue.addPiece (Piece<T>(p2, p3), new PowerLawFunction<T>(p2, p3, (T)0.9, (T)1.0, (T)0.2) );
+
+ return waterBlue;
+}
+
+template <typename T>
+PiecewiseFunction<T> generateAirRed()
+{
+ T p0 = (T) 0.;
+ T p1 = (T) 1.;
+
+ PiecewiseFunction<T> airRed;
+ airRed.addPiece (Piece<T>(p0, p1), new LinearFunction<T>(p0, p1, (T)0., (T)1.) );
+
+ return airRed;
+}
+
+template <typename T>
+PiecewiseFunction<T> generateAirGreen()
+{
+ T p0 = (T) 0.;
+ T p1 = (T) 1.;
+
+ PiecewiseFunction<T> airGreen;
+ airGreen.addPiece (Piece<T>(p0, p1), new LinearFunction<T>(p0, p1, (T)1., (T)0.) );
+
+ return airGreen;
+}
+
+template <typename T>
+PiecewiseFunction<T> generateAirBlue()
+{
+ T p0 = (T) 0.;
+ T p1 = (T) 1.;
+
+ PiecewiseFunction<T> airBlue;
+ airBlue.addPiece (Piece<T>(p0, p1), new LinearFunction<T>(p0, p1, (T)1., (T)1.) );
+
+ return airBlue;
+}
+
+
+template <typename T>
+PiecewiseFunction<T> generateFireRed()
+{
+ T p0 = (T) 0.;
+ T p1 = (T) 0.36;
+ T p3 = (T) 1.;
+
+ PiecewiseFunction<T> fireRed;
+ fireRed.addPiece (Piece<T>(p0, p1), new LinearFunction<T>(p0, p1, (T)0., (T)1.) );
+ fireRed.addPiece (Piece<T>(p1, p3), new LinearFunction<T>(p1, p3, (T)1., (T)1.) );
+
+ return fireRed;
+}
+
+template <typename T>
+PiecewiseFunction<T> generateFireGreen()
+{
+ T p0 = (T) 0.;
+ T p1 = (T) 0.36;
+ T p2 = (T) 0.75;
+ T p3 = (T) 1.;
+
+ PiecewiseFunction<T> fireGreen;
+ fireGreen.addPiece (Piece<T>(p0, p1), new LinearFunction<T>(p0, p1, (T)0., (T)0.) );
+ fireGreen.addPiece (Piece<T>(p1, p2), new LinearFunction<T>(p1, p2, (T)0., (T)1.) );
+ fireGreen.addPiece (Piece<T>(p2, p3), new LinearFunction<T>(p2, p3, (T)1., (T)1.) );
+
+ return fireGreen;
+}
+
+template <typename T>
+PiecewiseFunction<T> generateFireBlue()
+{
+ T p0 = (T) 0.;
+ T p2 = (T) 0.75;
+ T p3 = (T) 1.;
+
+ PiecewiseFunction<T> fireBlue;
+ fireBlue.addPiece (Piece<T>(p0, p2), new LinearFunction<T>(p0, p2, (T)0., (T)0.) );
+ fireBlue.addPiece (Piece<T>(p2, p3), new LinearFunction<T>(p2, p3, (T)0., (T)1.) );
+
+ return fireBlue;
+}
+
+
+template <typename T>
+PiecewiseFunction<T> generateLeeLooRed()
+{
+ T p0 = (T) 0.;
+ T p2 = (T) 3./8.;
+ T p3 = (T) 5./8.;
+ T p4 = (T) 7./8.;
+ T p5 = (T) 1.;
+ T p6 = (T) 9./8.;
+
+
+ PiecewiseFunction<T> leeLooRed;
+ leeLooRed.addPiece (Piece<T>(p0, p2), new LinearFunction<T>(p0, p2, (T)0., (T)0.) );
+ leeLooRed.addPiece (Piece<T>(p2, p3), new LinearFunction<T>(p2, p3, (T)0., (T)1.) );
+ leeLooRed.addPiece (Piece<T>(p3, p4), new LinearFunction<T>(p3, p4, (T)1., (T)1.) );
+ leeLooRed.addPiece (Piece<T>(p4, p5), new LinearFunction<T>(p4, p6, (T)1., (T)0.) );
+
+ return leeLooRed;
+}
+
+template <typename T>
+PiecewiseFunction<T> generateLeeLooGreen()
+{
+ T p0 = (T) 0.;
+ T p1 = (T) 1./8.;
+ T p2 = (T) 3./8.;
+ T p3 = (T) 5./8.;
+ T p4 = (T) 7./8.;
+ T p5 = (T) 1.;
+ T p6 = (T) 9/8;
+
+
+ PiecewiseFunction<T> leeLooGreen;
+ leeLooGreen.addPiece (Piece<T>(p0, p1), new LinearFunction<T>(p0, p1, (T)0., (T)0.) );
+ leeLooGreen.addPiece (Piece<T>(p1, p2), new LinearFunction<T>(p1, p2, (T)0., (T)1.) );
+ leeLooGreen.addPiece (Piece<T>(p2, p3), new LinearFunction<T>(p2, p3, (T)1., (T)1.) );
+ leeLooGreen.addPiece (Piece<T>(p3, p4), new LinearFunction<T>(p3, p4, (T)1., (T)0.) );
+ leeLooGreen.addPiece (Piece<T>(p4, p5), new LinearFunction<T>(p4, p6, (T)0., (T)0.) );
+
+ return leeLooGreen;
+}
+
+template <typename T>
+PiecewiseFunction<T> generateLeeLooBlue()
+{
+ T pm1 = (T) -1./8.;
+ T p0 = (T) 0.;
+ T p1 = (T) 1./8.;
+ T p2 = (T) 3./8.;
+ T p3 = (T) 5./8.;
+ T p5 = (T) 1.;
+
+
+ PiecewiseFunction<T> leeLooBlue;
+ leeLooBlue.addPiece (Piece<T>(p0, p1), new LinearFunction<T>(pm1, p1, (T)0., (T)1.) );
+ leeLooBlue.addPiece (Piece<T>(p1, p2), new LinearFunction<T>(p1, p2, (T)1., (T)1.) );
+ leeLooBlue.addPiece (Piece<T>(p2, p3), new LinearFunction<T>(p2, p3, (T)1., (T)0.) );
+ leeLooBlue.addPiece (Piece<T>(p3, p5), new LinearFunction<T>(p3, p5, (T)0., (T)0.) );
+
+ return leeLooBlue;
+}
+
+template <typename T>
+ColorMap<T> generateMap(std::string mapName)
+{
+ if (mapName == "earth") {
+ return ColorMap<T> (
+ generateEarthRed<T>(),
+ generateEarthGreen<T>(),
+ generateEarthBlue<T>() );
+ } else if (mapName == "water") {
+ return ColorMap<T> (
+ generateWaterRed<T>(),
+ generateWaterGreen<T>(),
+ generateWaterBlue<T>() );
+ } else if (mapName == "air") {
+ return ColorMap<T> (
+ generateAirRed<T>(),
+ generateAirGreen<T>(),
+ generateAirBlue<T>() );
+ } else if (mapName == "fire") {
+ return ColorMap<T> (
+ generateFireRed<T>(),
+ generateFireGreen<T>(),
+ generateFireBlue<T>() );
+ } else if (mapName == "leeloo") {
+ return ColorMap<T> (
+ generateLeeLooRed<T>(),
+ generateLeeLooGreen<T>(),
+ generateLeeLooBlue<T>() );
+ }
+ return ColorMap<T> (
+ generateLeeLooRed<T>(),
+ generateLeeLooGreen<T>(),
+ generateLeeLooBlue<T>() );
+}
+
+} // namespace mapGenerators
+
+} // namespace graphics
+
+} // namespace olb
+
+#endif