CQGLNetworkPainter Class Reference

#include <CQGLNetworkPainter.h>

Inheritance diagram for CQGLNetworkPainter:

Collaboration diagram for CQGLNetworkPainter:

Public Slots
void	triggerAnimationStep ()

Signals
void	endOfAnimationReached ()
void	signalZoomIn ()
void	signalZoomOut ()
void	stepChanged (int)

Public Member Functions
	CQGLNetworkPainter (const QGLFormat &format, QWidget *parent=0)
bool	createDataSets ()
void	createGraph (CLayout *lP)
void	drawArrow (CArrow a, CLMetabReferenceGlyph::Role role)
void	drawEdge (CGraphCurve &c)
void	drawGraph ()
void	drawNode (CCompartmentGraphNode &n)
void	drawNode (CGraphNode &n)
bool	export_bitmap (double x, double y, double width, double height, unsigned int imageWidth, unsigned int imageHeight, const QString &filename, const std::vector< size_t > frames)
double	fitToScreen ()
C_FLOAT64	getCurrentPositionX () const
C_FLOAT64	getCurrentPositionY () const
size_t	getCurrentStep () const
CDataEntity *	getDataSetAt (size_t stepNumber)
C_INT16	getFontSize ()
const CLPoint &	getGraphMax ()
const CLPoint &	getGraphMin ()
QImage	getImage ()
std::string	getNameForNodeKey (std::string key)
std::string	getNodeNameEntry (int i)
size_t	getNumberOfNodeEntries ()
size_t	getNumberOfSteps () const
C_FLOAT64	getZoomFactor () const
bool	isCircleMode ()
void	mapLabelsToCircles ()
void	mapLabelsToRectangles ()
void	pauseAnimation ()
void	rescaleDataSets (CVisParameters::SCALING_MODE scaleMode)
void	rescaleDataSetsWithNewMinMax (C_FLOAT64 oldMin, C_FLOAT64 oldMax, C_FLOAT64 newMin, C_FLOAT64 newMax, CVisParameters::SCALING_MODE scaleMode)
void	rescaleNode (std::string key, C_FLOAT64 newMin, C_FLOAT64 newMax, CVisParameters::SCALING_MODE scaleMode)
void	resetView ()
void	runAnimation ()
void	setConstantNodeSize (std::string key, C_FLOAT64 val)
void	setConstantNodeSizeForAllSteps (std::string key, C_FLOAT64 midValue)
void	setCurrentPosition (C_FLOAT64 x, C_FLOAT64 y)
void	setCurrentPositionX (C_FLOAT64 x)
void	setCurrentPositionY (C_FLOAT64 y)
void	setFontSizeForLabels (unsigned int fs)
void	setGraphSize (const CLPoint &min, const CLPoint &max)
void	setItemAnimated (std::string key, bool animatedP)
void	setNodeSize (std::string key, C_FLOAT64 val)
void	setNodeSizeWithoutChangingCurves (std::string key, C_FLOAT64 val)
void	setScaleMode (CVisParameters::SCALING_MODE scaleMode)
void	setZoomFactor (C_FLOAT64)
void	showStep (size_t i)
void	update ()
void	zoomGraph (C_FLOAT64 zoomFactor)
	~CQGLNetworkPainter ()

Public Attributes
bool	mDataPresentP
CSimSummaryInfo *	pSummaryInfo

Protected Member Functions
void	contextMenuEvent (QContextMenuEvent *event)
void	draw ()
void	initializeDisplayLists ()
void	initializeGL ()
void	initializeGraphPainter (QWidget *viewportWidget)
void	paintGL ()
void	printNodeInfoForKey (std::string key)
void	resizeGL (int w, int h)
void	testOpenGL ()

Static Protected Member Functions
static double	calculateAngle (const CLPoint &endPoint, const CLPoint &startPoint)
static std::vector< std::pair < float, float > >	calculateCirclePoints (unsigned int n)

Private Types
enum	shapeOfLabels { CIRCLE, RECTANGLE }

Private Slots
void	setFontSize ()
void	zoomIn ()
void	zoomOut ()

Private Member Functions
void	adaptCurveForCircle (std::multimap< std::string, CGraphCurve >::iterator it, CLBoundingBox box)
void	adaptCurveForRectangles (std::multimap< std::string, CGraphCurve >::iterator it, CLBoundingBox box)
void	addMetaboliteForAnimation (std::string key)
bool	checkCurve (CGraphCurve *curve, CGraphCurve curveR, CLBoundingBox box)
void	createActions ()
void	createTextureForAllLabels ()
void	drawColorLegend ()
void	drawStringAt (std::string s, C_FLOAT64 x, C_FLOAT64 y, C_FLOAT64 w, C_FLOAT64 h, QColor bgCol)
int	getLabelWindowWidth (int width)
CLPoint	getPointNearCircle (CLBoundingBox r, CLPoint p, C_INT16 d)
CLPoint	getPointOnCircle (CLBoundingBox r, CLPoint p)
CLPoint	getPointOnRectangle (CLBoundingBox r, CLPoint p)
RGTextureSpec *	getTextureForText (const std::string &text, const std::string &fontName, unsigned int fontSize)
int	getTextWidth (const std::string &text, const std::string &fontName, unsigned int fontSize)
void	printAvailableFonts ()
void	printNodeMap ()
void	removeMetaboliteForAnimation (std::string key)
RGTextureSpec *	RG_createTextureForText (const std::string &text, const std::string &fontName, unsigned int fontSize)
void	RG_drawStringAt (std::string s, C_INT32 x, C_INT32 y, C_INT32 w, C_INT32 h)
int	round2powN (double d)
void	updateEdge (CLLineSegment line)
void	updateGraphWithNodeSizes ()
void	zoom (double zoomFactor)

Private Attributes
std::map< std::string, CCompartmentGraphNode >	compartmentNodeMap
std::vector< CGraphCurve >	curvesWithArrow
GLuint	graphObjList
std::map< std::string, std::string >	keyMap
std::map< std::string, std::string >	labelNodeMap
std::map< std::string, RGTextureSpec * >	labelTextureMap
GLfloat	mAnimatedSpeciesColor [4]
GLclampf	mBackgroundColor [4]
std::vector< std::pair< float, float > >	mCirclePoints
GLfloat	mCompartmentColor [4]
float	mCompartmentShadowXOffset
float	mCompartmentShadowYOffset
GLfloat	mConstantSpeciesColor [4]
C_FLOAT64	mCurrentPositionX
C_FLOAT64	mCurrentPositionY
C_FLOAT64	mCurrentZoom
std::vector< CDataEntity >	mDataSets
GLuint	mDisplayLists
bool	mDrawShadows
QFont	mf
std::string	mFontname
unsigned int	mFontsize
double	mFontsizeDouble
GLfloat	mFrameColor [4]
CLPoint	mgraphMax
CLPoint	mgraphMin
GLfloat	mInanimatedSpeciesColor [4]
bool	mIsInitialized
	flag that indicates whether OpenGL was initialized More...
shapeOfLabels	mLabelShape
unsigned int	mNumCirclePoints
CVisParameters::SCALING_MODE	mScaleMode
GLfloat	mShadowColor [4]
GLfloat	mSpeciesColor [4]
GLfloat	mSpeciesReferenceColor [4]
float	mSpeciesShadowXOffset
float	mSpeciesShadowYOffset
GLfloat	mTextColor [4]
std::multimap< std::string, CArrow >	nodeArrowMap
std::multimap< std::string, CGraphCurve >	nodeCurveMap
std::map< std::string, CGraphNode >	nodeMap
CQLayoutMainWindow *	pParentLayoutWindow
bool	preserveMinLabelHeightP
QTimer *	regularTimer
QAction *	setFontSizeAction
std::set< std::string >	setOfConstantMetabolites
std::set< std::string >	setOfDisabledMetabolites
size_t	stepShown
GLuint	textureNames [1]
std::vector< std::string >	viewerCompartmentNodes
std::vector< CGraphCurve >	viewerCurves
std::vector< CLabel >	viewerLabels
std::vector< std::string >	viewerNodes
QAction *	zoomInAction
QAction *	zoomOutAction

Static Private Attributes
static const float	COMPARTMENT_DEPTH = 0.001f
static const float	COMPARTMENT_FRAME_DEPTH = 0.0011f
static const float	COMPARTMENT_SHADOW_DEPTH = 0.0009f
static const C_FLOAT64	DEFAULT_NODE_SIZE
static const C_INT32	MIN_HEIGHT = 10
static const GLfloat	MIRROR_X [16]
static const GLfloat	MIRROR_Y [16]
static const float	SPECIES_DEPTH = 0.005f
static const float	SPECIES_FRAME_DEPTH = 0.0051f
static const float	SPECIES_SHADOW_DEPTH = 0.0049f
static const float	SPECIESREFERENCE_DEPTH = 0.003f

Detailed Description

Definition at line 62 of file CQGLNetworkPainter.h.

Member Enumeration Documentation

enum CQGLNetworkPainter::shapeOfLabels

private

Enumerator
CIRCLE
RECTANGLE

Definition at line 285 of file CQGLNetworkPainter.h.

{CIRCLE, RECTANGLE};

Constructor & Destructor Documentation

CQGLNetworkPainter::CQGLNetworkPainter	(	const QGLFormat &	format,
		QWidget *	parent = 0
	)

Definition at line 112 of file CQGLNetworkPainter.cpp.

References initializeGraphPainter().

  : QGLWidget(format, parent),
    mIsInitialized(false)
{
  initializeGraphPainter(parent);
}

CQGLNetworkPainter::~CQGLNetworkPainter

(

)

Definition at line 119 of file CQGLNetworkPainter.cpp.

References labelTextureMap, and mDisplayLists.

{
  std::map<std::string, RGTextureSpec*>::iterator it = labelTextureMap.begin(), endit = labelTextureMap.end();

  while (it != endit)
    {
      delete[] it->second->textureData;
      delete it->second;
      ++it;
    }

  // delete the node display list
  glDeleteLists(this->mDisplayLists, 17);
}

Member Function Documentation

void CQGLNetworkPainter::adaptCurveForCircle ( std::multimap< std::string, CGraphCurve >::iterator  it, CLBoundingBox  box  )

private

Definition at line 2582 of file CQGLNetworkPainter.cpp.

References CLLineSegment::getBase1(), CLLineSegment::getBase2(), CLLineSegment::getEnd(), getPointNearCircle(), CLLineSegment::getStart(), CLPoint::getX(), CLPoint::getY(), CLLineSegment::isBezier(), mCurrentZoom, nodeArrowMap, and CLLineSegment::setEnd().

Referenced by mapLabelsToCircles().

{
  CLLineSegment* pLastSeg = (*it).second.getSegmentAt((*it).second.getNumCurveSegments() - 1);
  CLPoint pointOnCircle;

  if (pLastSeg->isBezier())
    pointOnCircle = getPointNearCircle(box, pLastSeg->getBase2(), 1);
  else
    pointOnCircle = getPointNearCircle(box, pLastSeg->getStart(), 1);

  pLastSeg->setEnd(pointOnCircle);

  // create corresponding arrow, if necessary and insert it into map
  if (((*it).second).hasArrowP())
    {
      CLPoint p = pLastSeg->getEnd();
      CArrow *ar;

      if (pLastSeg->isBezier())
        {
          CLPoint to = pLastSeg->getBase2();
          CLPoint p = pLastSeg->getEnd();

          // check if the second base point and the endpoint are identical
          if (fabs(p.getX() - to.getX() + p.getY() - to.getY()) < 1e-8)
            {
              // if yes, take the first basepoint
              to = pLastSeg->getBase1();

              // if they are still identical take the start point because
              // it is a straight line
              if (fabs(p.getX() - to.getX() + p.getY() - to.getY()) < 1e-8)
                {
                  to = pLastSeg->getStart();
                }
            }

          CLLineSegment segForArrow = CLLineSegment(to, pLastSeg->getEnd());
          ar = new CArrow(segForArrow, pLastSeg->getEnd().getX(), pLastSeg->getEnd().getY(), this->mCurrentZoom);
        }
      else
        {
          ar = new CArrow(*pLastSeg, p.getX(), p.getY(), this->mCurrentZoom);
        }

      nodeArrowMap.insert(std::pair<std::string, CArrow>
                          ((*it).first, *ar));
      ((*it).second).setArrowP(true);
      ((*it).second).setArrow(*ar);
    }
}

void CQGLNetworkPainter::adaptCurveForRectangles ( std::multimap< std::string, CGraphCurve >::iterator  it, CLBoundingBox  box  )

private

Definition at line 2635 of file CQGLNetworkPainter.cpp.

References CLLineSegment::getBase1(), CLLineSegment::getBase2(), CLLineSegment::getEnd(), getPointOnRectangle(), CLLineSegment::getStart(), CLPoint::getX(), CLPoint::getY(), CLLineSegment::isBezier(), mCurrentZoom, nodeArrowMap, and CLLineSegment::setEnd().

Referenced by mapLabelsToRectangles().

{
  // while (it != nodeCurveMap.end()){
  CLLineSegment* pLastSeg = (*it).second.getSegmentAt((*it).second.getNumCurveSegments() - 1);
  CLPoint pointOnRect;

  if (pLastSeg->isBezier())
    pointOnRect = getPointOnRectangle(box, pLastSeg->getBase2());
  else
    pointOnRect = getPointOnRectangle(box, pLastSeg->getStart());

  pLastSeg->setEnd(pointOnRect);

  // create corresponding arrow, if necessary and insert it into map
  CLPoint p = pLastSeg->getEnd();

  if (((*it).second).hasArrowP())
    {
      CArrow *ar;

      if (pLastSeg->isBezier())
        {
          CLPoint to = pLastSeg->getBase2();
          CLPoint p = pLastSeg->getEnd();

          // check if the second base point and the endpoint are identical
          if (fabs(p.getX() - to.getX() + p.getY() - to.getY()) < 1e-8)
            {
              // if yes, take the first basepoint
              to = pLastSeg->getBase1();

              // if they are still identical take the start point because
              // it is a straight line
              if (fabs(p.getX() - to.getX() + p.getY() - to.getY()) < 1e-8)
                {
                  to = pLastSeg->getStart();
                }
            }

          CLLineSegment segForArrow = CLLineSegment(to, pLastSeg->getEnd());
          ar = new CArrow(segForArrow, pLastSeg->getEnd().getX(), pLastSeg->getEnd().getY(), this->mCurrentZoom);
        }
      else
        {
          ar = new CArrow(*pLastSeg, p.getX(), p.getY(), this->mCurrentZoom);
        }

      nodeArrowMap.insert(std::pair<std::string, CArrow>
                          ((*it).first, *ar));
      ((*it).second).setArrowP(true);
      ((*it).second).setArrow(*ar);
    }
}

void CQGLNetworkPainter::addMetaboliteForAnimation ( std::string  key )

private

double CQGLNetworkPainter::calculateAngle ( const CLPoint &  endPoint, const CLPoint &  startPoint  )

staticprotected

Calculates the angle of the given line and the positive x axis. The returned value is in degrees.

Definition at line 1408 of file CQGLNetworkPainter.cpp.

References CLPoint::getX(), and CLPoint::getY().

Referenced by drawArrow().

{
  double deltaX = endPoint.getX() - startPoint.getX();
  double deltaY = endPoint.getY() - startPoint.getY();
  double angle = 0.0;

  if (deltaY == 0.0)
    {
      if (deltaX == 0.0)
        {
          return std::numeric_limits<double>::quiet_NaN();
        }

      // we have a horizontal line
      if (deltaX < 0.0)
        {
          angle = 180.0;
        }
    }
  else if (deltaX == 0.0)
    {
      if (deltaY == 0.0)
        {
          return std::numeric_limits<double>::quiet_NaN();
        }

      // we have a vertical line
      if (deltaX < 0.0)
        {
          angle = 270.0;
        }
      else
        {
          angle = 90.0f;
        }
    }
  else
    {
      double slope = deltaY / deltaX;
      angle = 180.0 * atan(slope) / M_PI;

      if (angle < 0.0)
        {
          angle += 360.0;
        }

      // now we have to find out in which quadrant the angle really is
      if (deltaX < 0.0)
        {
          if (deltaY > 0.0) // 2.quadrant; subtract 180
            {
              angle -= 180;
            }
          else // 3. quadrant; add 180
            {
              angle += 180.0;
            }
        }
    }

  return angle;
}

std::vector< std::pair< float, float > > CQGLNetworkPainter::calculateCirclePoints ( unsigned int  n )

staticprotected

Calculates a circle with n points. The points are returned as pairs of x,y values in a vector. The points are calculated for a circle with diameter 1.

Definition at line 3200 of file CQGLNetworkPainter.cpp.

Referenced by initializeGraphPainter().

{
  std::vector<std::pair<float, float> > result;
  unsigned int i;
  double angle;

  for (i = 0; i <= n; ++i)
    {
      angle = 2 * M_PI * i / n;
      result.push_back(std::pair<float, float>(cos(angle) * 0.5, sin(angle) * 0.5));
    }

  return result;
}

bool CQGLNetworkPainter::checkCurve ( CGraphCurve *  curve, CGraphCurve  curveR, CLBoundingBox  box  )

private

Definition at line 788 of file CQGLNetworkPainter.cpp.

References C_FLOAT64, CLBoundingBox::getDimensions(), CLDimensions::getHeight(), CLCurve::getListOfPoints(), CLBoundingBox::getPosition(), CLDimensions::getWidth(), CLPoint::getX(), CLPoint::getY(), CGraphCurve::invertOrderOfPoints(), CLPoint::setX(), and CLPoint::setY().

Referenced by createGraph().

{
  bool inverted = false;
  // first checks whether the start point or the end point of the curve is closer to the center of the box defining the reactant node
  CLPoint center; // center of bounding box for node
  center.setX(box.getPosition().getX() + (box.getDimensions().getWidth() / 2.0));
  center.setY(box.getPosition().getY() + (box.getDimensions().getHeight() / 2.0));

  // get start and end point of curve (start point of first segment and end point of last segment)
  std::vector <CLPoint> points = curve->getListOfPoints();

  if (points.size() > 1)
    {
      // if there are at least 2 points
      CLPoint s = points[0];
      CLPoint e = points[points.size() - 1];
      // now compute the distances from these points to the center

      C_FLOAT64 dist1 = sqrt(((center.getX() - s.getX()) * (center.getX() - s.getX())) +
                             ((center.getY() - s.getY()) * (center.getY() - s.getY())));
      C_FLOAT64 dist2 = sqrt(((center.getX() - e.getX()) * (center.getX() - e.getX())) +
                             ((center.getY() - e.getY()) * (center.getY() - e.getY())));

      if (dist1 < dist2)
        {
          // if the start point of the curve is closer to the node than the end point
          // the curve direction should be TOWARDS the node, not away from it
          curve->invertOrderOfPoints(); // invert the order of the points in the curve
          inverted = true;
        }
    }

  return inverted;
}

void CQGLNetworkPainter::contextMenuEvent ( QContextMenuEvent *  event )

protected

Definition at line 2845 of file CQGLNetworkPainter.cpp.

References setFontSizeAction, zoomInAction, and zoomOutAction.

{
  QMenu *pContextMenu = new QMenu();
  pContextMenu->addAction(this->zoomInAction);
  pContextMenu->addAction(this->zoomOutAction);
  pContextMenu->addAction(this->setFontSizeAction);
  pContextMenu->popup(cme->globalPos());
  delete pContextMenu;
}

void CQGLNetworkPainter::createActions ( )

private

Definition at line 2693 of file CQGLNetworkPainter.cpp.

References setFontSize(), setFontSizeAction, zoomIn(), zoomInAction, zoomOut(), and zoomOutAction.

Referenced by initializeGraphPainter().

{
  zoomInAction = new QAction("Zoom in", this);
  zoomInAction->setShortcut(Qt::CTRL + Qt::Key_P);
  connect(zoomInAction, SIGNAL(triggered()), this, SLOT(zoomIn()));

  zoomOutAction = new QAction("Zoom out", this);
  zoomOutAction->setShortcut(Qt::CTRL + Qt::Key_M);
  connect(zoomOutAction, SIGNAL(triggered()), this, SLOT(zoomOut()));

  setFontSizeAction = new QAction("Set Font Size", this);
  setFontSizeAction->setShortcut(Qt::CTRL + Qt::Key_F);
  connect(setFontSizeAction, SIGNAL(triggered()), this, SLOT(setFontSize()));
}

bool CQGLNetworkPainter::createDataSets

(

)

Definition at line 2050 of file CQGLNetworkPainter.cpp.

References CTimeSeries::allocate(), C_FLOAT64, CTimeSeries::compile(), COutputInterface::DURING, CVisParameters::EPSILON, CTimeSeries::getConcentrationData(), CCopasiRootContainer::getDatamodelList(), CTimeSeries::getKey(), CSimSummaryInfo::getMaxForSpecies(), CQLayoutMainWindow::getMaxNodeSize(), CSimSummaryInfo::getMaxOverallConcentration(), CSimSummaryInfo::getMinForSpecies(), CQLayoutMainWindow::getMinNodeSize(), CSimSummaryInfo::getMinOverallConcentration(), CTimeSeries::getNumVariables(), CTimeSeries::getRecordedSteps(), CQLayoutMainWindow::getScalingMode(), CTrajectoryTask::getTimeSeries(), CTimeSeries::getTitle(), CVisParameters::INDIVIDUAL_SCALING, CQLayoutMainWindow::insertValueTable(), keyMap, max, mDataPresentP, mDataSets, CTimeSeries::output(), pParentLayoutWindow, pSummaryInfo, CDataEntity::putOrigValueForSpecies(), CDataEntity::putValueForSpecies(), CSimSummaryInfo::setMaxOverallConcentration(), CSimSummaryInfo::storeMax(), and CSimSummaryInfo::storeMin().

Referenced by CQLayoutMainWindow::loadData(), and runAnimation().

{
  int counter = 0;
  bool loadDataSuccessful = false;
  assert(CCopasiRootContainer::getDatamodelList()->size() > 0);

  if ((*CCopasiRootContainer::getDatamodelList())[0] != NULL)
    {
      CTrajectoryTask *ptask = dynamic_cast< CTrajectoryTask * >((*(*CCopasiRootContainer::getDatamodelList())[0]->getTaskList())["Time-Course"]);
      const CTimeSeries* pTimeSer = &ptask->getTimeSeries();
      CTimeSeries dummyTimeSeries;

      if (pTimeSer->getRecordedSteps() == 0)
        {
          // create a dummy time series from the current state
          dummyTimeSeries.allocate(1);
          assert(CCopasiRootContainer::getDatamodelList()->size() > 0);
          CCopasiDataModel* pDataModel = (*CCopasiRootContainer::getDatamodelList())[0];
          assert(pDataModel != NULL);
          std::vector<CCopasiContainer*> tmpV;
          dummyTimeSeries.compile(tmpV, pDataModel);
          dummyTimeSeries.output(COutputInterface::DURING);
          assert(dummyTimeSeries.getRecordedSteps() == 1);
          pTimeSer = &dummyTimeSeries; // point to the dummy time series
        }

      if (pTimeSer->getNumVariables() > 0)
        {
          mDataSets.clear(); // remove old data sets
          pSummaryInfo = new CSimSummaryInfo(pTimeSer->getRecordedSteps(), pTimeSer->getNumVariables(),
                                             pTimeSer->getConcentrationData(pTimeSer->getRecordedSteps() - 1, 0) - pTimeSer->getConcentrationData(0, 0));
          unsigned int i;
          unsigned int t;
          C_FLOAT64 val;
          std::string name;
          std::string objKey;
          std::string ndKey;
          C_FLOAT64 minR;
          C_FLOAT64 maxR;
          C_FLOAT64 maxAll = 0.0;

          // now get some info about the data set such as the maximum concentration values for each reactant
          for (i = 0; i < pTimeSer->getNumVariables(); i++) // iterate on reactants
            {
              maxR = - std::numeric_limits< C_FLOAT64 >::max();
              minR = std::numeric_limits< C_FLOAT64 >::max();
              name = pTimeSer->getTitle(i);
              objKey = pTimeSer->getKey(i);
              std::map<std::string, std::string>::iterator iter = keyMap.find(objKey);

              if (iter != keyMap.end())
                {
                  // if there is a node (key)
                  ndKey = (keyMap.find(objKey))->second;

                  for (t = 0; t < pTimeSer->getRecordedSteps(); t++) // iterate on time steps t=0..n
                    {
                      val = pTimeSer->getConcentrationData(t, i);

                      if (val > maxR)
                        maxR = val;

                      if (val < minR)
                        minR = val;
                    }

                  pSummaryInfo->storeMax(ndKey, maxR);
                  pSummaryInfo->storeMin(ndKey, minR);

                  if (maxR > maxAll)
                    maxAll = maxR;
                }
            }

          pSummaryInfo->setMaxOverallConcentration(maxAll);
          // now create data sets for visualization/animation
          // try to get VisParameters from parent (CQLayoutMainWindow)
          C_FLOAT64 minNodeSize = 10;
          C_FLOAT64 maxNodeSize = 100;

          if (pParentLayoutWindow != NULL)
            {
              minNodeSize = pParentLayoutWindow->getMinNodeSize();
              maxNodeSize = pParentLayoutWindow->getMaxNodeSize();
            }

          for (t = 0; t < pTimeSer->getRecordedSteps(); t++)  // iterate on time steps t=0..n
            {
              CDataEntity dataSet;

              for (i = 0; i < pTimeSer->getNumVariables(); i++) // iterate on reactants
                {
                  objKey = pTimeSer->getKey(i); // object key os SBML species
                  std::map<std::string, std::string>::iterator iter = keyMap.find(objKey);

                  if (iter != keyMap.end())
                    {
                      // if there is a node (key)
                      ndKey = (keyMap.find(objKey))->second; // key of graphical node
                      val = pTimeSer->getConcentrationData(t, i); // get concentration of species i at time point t
                      C_FLOAT64 scaledVal;

                      // now scale value;
                      if (pParentLayoutWindow->getScalingMode() == CVisParameters::INDIVIDUAL_SCALING)
                        {
                          minR = pSummaryInfo->getMinForSpecies(ndKey);
                          maxR = pSummaryInfo->getMaxForSpecies(ndKey);
                        }
                      else
                        {
                          // == CVisParameters.GLOBAL_SCALING
                          minR = pSummaryInfo->getMinOverallConcentration();
                          maxR = pSummaryInfo->getMaxOverallConcentration();
                        }

                      if ((maxR - minR) > CVisParameters::EPSILON)
                        scaledVal = minNodeSize +
                                    (((maxNodeSize - minNodeSize) / (maxR - minR))
                                     * (val - minR));
                      else
                        scaledVal = (maxNodeSize + minNodeSize) / 2.0;

                      // put scaled value in data entity (collection of scaled values for one step)
                      dataSet.putValueForSpecies(ndKey, scaledVal);
                      dataSet.putOrigValueForSpecies(ndKey, val);
                    }
                }

              // now collect data set
              mDataSets.push_back(dataSet);
              counter++;
            }

          loadDataSuccessful = true;
        }
      else
        {
        }
    }

  this->mDataPresentP = loadDataSuccessful;

  if (loadDataSuccessful)
    {
      // if loading was successful, parent should create data table to show it in its window
      if (!mDataSets.empty())
        {
          pParentLayoutWindow->insertValueTable(mDataSets[0]);
        }
    }

  return loadDataSuccessful;
}

void CQGLNetworkPainter::createGraph

(

CLayout *

lP

)

Definition at line 583 of file CQGLNetworkPainter.cpp.

References CLMetabReferenceGlyph::ACTIVATOR, checkCurve(), compartmentNodeMap, curvesWithArrow, CLLineSegment::getBase1(), CLLineSegment::getBase2(), CLCurve::getCurveSegments(), CLayout::getDimensions(), CLLineSegment::getEnd(), CLDimensions::getHeight(), CCopasiObject::getKey(), CLayout::getListOfCompartmentGlyphs(), CLayout::getListOfMetaboliteGlyphs(), CLayout::getListOfReactionGlyphs(), CLayout::getListOfTextGlyphs(), CLLineSegment::getStart(), CLDimensions::getWidth(), CLPoint::getX(), CLPoint::getY(), CLMetabReferenceGlyph::INHIBITOR, CLLineSegment::isBezier(), keyMap, labelNodeMap, mCurrentZoom, CLMetabReferenceGlyph::MODIFIER, nodeArrowMap, nodeCurveMap, nodeMap, CLMetabReferenceGlyph::PRODUCT, CGraphCurve::setArrow(), CGraphCurve::setArrowP(), setGraphSize(), CGraphCurve::setRole(), CLMetabReferenceGlyph::SIDEPRODUCT, CCopasiVector< T >::size(), viewerCompartmentNodes, viewerCurves, viewerLabels, and viewerNodes.

Referenced by CQGLViewport::createGraph().

{
  keyMap.clear();
  compartmentNodeMap.clear();
  nodeMap.clear();
  labelNodeMap.clear();
  nodeArrowMap.clear();
  nodeCurveMap.clear();
  viewerNodes.clear();
  viewerCurves.clear();
  viewerLabels.clear();
  curvesWithArrow.clear();
  int numberOfInvertedCurves = 0;
  // copy graph to local variables
  CCopasiVector<CLCompartmentGlyph> compartmentNodes = lP->getListOfCompartmentGlyphs();
  viewerCompartmentNodes = std::vector<std::string>();
  unsigned int i;

  for (i = 0; i < compartmentNodes.size(); i++)
    {
      std::string nKey = (*compartmentNodes[i]).getKey();
      std::string oKey = (*compartmentNodes[i]).getModelObjectKey();
      viewerCompartmentNodes.push_back(nKey);
      compartmentNodeMap.insert(std::pair<std::string, CCompartmentGraphNode>
                                (nKey,
                                 CCompartmentGraphNode(*compartmentNodes[i])));
      keyMap.insert(std::pair<std::string, std::string>
                    (oKey, nKey));
    }

  CCopasiVector<CLMetabGlyph> nodes;
  nodes = lP->getListOfMetaboliteGlyphs();
  viewerNodes = std::vector<std::string>();

  for (i = 0; i < nodes.size(); i++)
    {
      std::string nKey = (*nodes[i]).getKey();
      std::string oKey = (*nodes[i]).getModelObjectKey();
      viewerNodes.push_back(nKey);
      nodeMap.insert(std::pair<std::string, CGraphNode>
                     (nKey,
                      CGraphNode(*nodes[i])));
      keyMap.insert(std::pair<std::string, std::string>
                    (oKey, nKey));
    }

  CCopasiVector<CLReactionGlyph> reactions;
  reactions = lP->getListOfReactionGlyphs();

  //now extract curves to draw from reaction
  viewerCurves = std::vector<CGraphCurve>();

  //first get reaction arrow
  for (i = 0; i < reactions.size(); i++)
    {
      CGraphCurve curveR = CGraphCurve((reactions[i])->getCurve());
      viewerCurves.push_back(curveR);

      CCopasiVector<CLMetabReferenceGlyph> edgesToNodesOfReaction;
      edgesToNodesOfReaction = reactions[i]->getListOfMetabReferenceGlyphs();
      unsigned int j2;

      for (j2 = 0; j2 < edgesToNodesOfReaction.size(); j2++)
        {
          CGraphCurve curve = CGraphCurve(edgesToNodesOfReaction[j2]->getCurve());
          std::string nodeKey = "";

          if (edgesToNodesOfReaction[j2]->getMetabGlyph() != NULL) // i.e. there is an associated node
            {
              nodeKey = std::string(edgesToNodesOfReaction[j2]->getMetabGlyph()->getKey());
              std::map<std::string, CGraphNode>::iterator itNode;
              itNode = nodeMap.find(nodeKey);

              if (itNode != nodeMap.end())
                {
                  CLBoundingBox box = (*itNode).second.getBoundingBox();

                  if (this->checkCurve(&curve, curveR, box))
                    numberOfInvertedCurves++;
                }
            }

          CLMetabReferenceGlyph::Role r = edgesToNodesOfReaction[j2]->getRole();
          curve.setRole(r);

          if (edgesToNodesOfReaction[j2]->getMetabGlyph() != NULL)  // if there is an associated species node look whether an arrow has to be created
            {
              // if role is product or sideproduct, create arrow for line
              if ((r == CLMetabReferenceGlyph::PRODUCT) || (r == CLMetabReferenceGlyph::SIDEPRODUCT) || (r == CLMetabReferenceGlyph::ACTIVATOR) || (r == CLMetabReferenceGlyph::INHIBITOR) || (r == CLMetabReferenceGlyph::MODIFIER))
                {
                  // create arrows just for edges to products or sideproducts
                  std::vector<CLLineSegment> segments = curve.getCurveSegments();

                  if (! segments.empty())
                    {

                      CLLineSegment lastSeg = segments[segments.size() - 1];

                      if ((r == CLMetabReferenceGlyph::ACTIVATOR) || (r == CLMetabReferenceGlyph::INHIBITOR) || (r == CLMetabReferenceGlyph::MODIFIER))
                        {
                          lastSeg = segments[0];
                        }

                      CLPoint p = lastSeg.getEnd();
                      CArrow *ar;

                      if (lastSeg.isBezier())
                        {
                          CLPoint to = lastSeg.getBase2();
                          CLPoint p = lastSeg.getEnd();

                          // check if the second base point and the endpoint are identical
                          if (fabs(p.getX() - to.getX() + p.getY() - to.getY()) < 1e-8)
                            {
                              // if yes, take the first basepoint
                              to = lastSeg.getBase1();

                              // if they are still identical take the start point because
                              // it is a straight line
                              if (fabs(p.getX() - to.getX() + p.getY() - to.getY()) < 1e-8)
                                {
                                  to = lastSeg.getStart();
                                }
                            }

                          CLLineSegment segForArrow;

                          if ((r == CLMetabReferenceGlyph::ACTIVATOR) || (r == CLMetabReferenceGlyph::INHIBITOR) || (r == CLMetabReferenceGlyph::MODIFIER))
                            {
                              segForArrow = CLLineSegment(to, lastSeg.getEnd());
                            }
                          else
                            {
                              segForArrow = CLLineSegment(to, lastSeg.getEnd());
                            }

                          if ((r == CLMetabReferenceGlyph::ACTIVATOR) || (r == CLMetabReferenceGlyph::INHIBITOR) || (r == CLMetabReferenceGlyph::MODIFIER))
                            {
                              ar = new CArrow(segForArrow, lastSeg.getEnd().getX(), lastSeg.getEnd().getY(), this->mCurrentZoom);
                            }
                          else
                            {
                              ar = new CArrow(segForArrow, lastSeg.getEnd().getX(), lastSeg.getEnd().getY(), this->mCurrentZoom);
                            }
                        }
                      else
                        {
                          if ((r == CLMetabReferenceGlyph::ACTIVATOR) || (r == CLMetabReferenceGlyph::INHIBITOR) || (r == CLMetabReferenceGlyph::MODIFIER))
                            {
                              ar = new CArrow(lastSeg, p.getX(), p.getY(), this->mCurrentZoom);
                            }
                          else
                            {
                              ar = new CArrow(lastSeg, p.getX(), p.getY(), this->mCurrentZoom);
                            }
                        }

                      curve.setArrowP(true);
                      curve.setArrow(*ar);
                      delete ar;
                    }
                }

              if (nodeKey != "")
                {
                  nodeCurveMap.insert(std::pair<std::string, CGraphCurve>
                                      (nodeKey,
                                       curve));
                }
            }
          else
            {
              // if no species node is associated with the curve: just store curve
              viewerCurves.push_back(curve); // just collect curve in order to be shown within the graph
            }
        } // end j
    } // end i (reactions)

  CCopasiVector<CLTextGlyph> labels;
  labels = lP->getListOfTextGlyphs();
  viewerLabels = std::vector<CLabel>();
  std::map<std::string, CGraphNode>::iterator itNode;

  for (i = 0; i < labels.size(); i++)
    {
      labelNodeMap.insert(std::pair<std::string, std::string>
                          (labels[i]->getKey(),
                           labels[i]->getGraphicalObjectKey()));
      std::string s1 = labels[i]->getKey();
      std::string s2 = labels[i]->getGraphicalObjectKey();
      viewerLabels.push_back(CLabel(*labels[i]));
      itNode = nodeMap.find(labels[i]->getGraphicalObjectKey());

      if (itNode != nodeMap.end())
        {
          (*itNode).second.setLabelText(labels[i]->getText());
        }
    }

  CLPoint p1 = CLPoint(0.0, 0.0);
  CLPoint p2 = CLPoint(lP->getDimensions().getWidth(), lP->getDimensions().getHeight());
  this->setGraphSize(p1, p2);
}

void CQGLNetworkPainter::createTextureForAllLabels ( )

private

Definition at line 1627 of file CQGLNetworkPainter.cpp.

References C_INT32, labelTextureMap, mFontname, mFontsize, RG_createTextureForText(), and viewerLabels.

Referenced by setFontSizeForLabels(), and zoom().

{
  std::map<std::string, RGTextureSpec*>::iterator it = labelTextureMap.begin(), endit = labelTextureMap.end();

  while (it != endit)
    {
      delete[] it->second->textureData;
      delete it->second;
      ++it;
    }

  labelTextureMap.clear();
  unsigned int i = 0;

  for (i = 0; i < viewerLabels.size(); i++)
    {
      C_INT32 fontSize = mFontsize;
      RGTextureSpec* pTexture = RG_createTextureForText(viewerLabels[i].getText(), mFontname, fontSize);
      labelTextureMap.insert(std::pair<std::string, RGTextureSpec*>
                             (viewerLabels[i].getText(),
                              pTexture));
    }
}

void CQGLNetworkPainter::draw ( )

protected

Definition at line 577 of file CQGLNetworkPainter.cpp.

References drawGraph().

Referenced by paintGL().

{
  glLoadIdentity();
  drawGraph();
}

void CQGLNetworkPainter::drawArrow	(	CArrow	a,
		CLMetabReferenceGlyph::Role	role
	)

Definition at line 1471 of file CQGLNetworkPainter.cpp.

References CLMetabReferenceGlyph::ACTIVATOR, calculateAngle(), CArrow::getEndOfLine(), CArrow::getStartOfLine(), CLPoint::getX(), CLPoint::getY(), CLMetabReferenceGlyph::INHIBITOR, mDisplayLists, CLMetabReferenceGlyph::MODIFIER, mSpeciesReferenceColor, CLMetabReferenceGlyph::PRODUCT, and CLMetabReferenceGlyph::SIDEPRODUCT.

Referenced by drawEdge().

{
  // here we draw the arrow heads depending on the passed in role, a different
  // head is drawn
  // Since right now the edge width is fixed to a value of 2.0 and does not
  // scale with the rest of the diagram, it probably does not make sense to
  // scale the arrow heads.

  // we need to calculate the slope of the line at the attachment point

  // first get the two points defining the line segment (curve)
  CLPoint p2 = a.getStartOfLine();
  CLPoint p1 = a.getEndOfLine();
  // p1 and p2 define a line where the arrow peak can be placed onto,
  // peak should be at p1, the arrow peak is just a triangle

  // calculate the angle of the line from the x axis
  // since all arrow heads go along the y axis, we have to subtract 90° from
  // the angle to get the correct rotation angle
  double angle;

  if ((role == CLMetabReferenceGlyph::PRODUCT) || (role == CLMetabReferenceGlyph::SIDEPRODUCT))
    {
      angle = calculateAngle(p1, p2);
    }
  else
    {
      angle = calculateAngle(p2, p1);
    }

  if (angle != angle)
    {
      return; // we got NaN
    }

  angle -= 90.0;

  // so we need to rotate the head by angle degrees and move it to
  // p1.getX(),p1.getY()

  // first compute parameters of equation of line and point on line where arrow intersects line
  // now draw polygon, using vertices from triangle
  // now create triangle;
  glPushMatrix();
  glColor4fv(mSpeciesReferenceColor);

  if ((role == CLMetabReferenceGlyph::PRODUCT) || (role == CLMetabReferenceGlyph::SIDEPRODUCT))
    {
      glTranslatef(p1.getX(), p1.getY(), 0.0f);
      glRotatef(angle, 0.0f, 0.0f, 1.0f);
      glScalef(3.0f, 3.0f, 1.0f);
      glCallList(mDisplayLists + 7);
    }
  else
    {
      if (role == CLMetabReferenceGlyph::MODIFIER)
        {
          glTranslatef(p2.getX(), p2.getY(), 0.0f);
          glRotatef(angle, 0.0f, 0.0f, 1.0f);
          glScalef(3.0f, 3.0f, 1.0f);
          glCallList(mDisplayLists + 9);
        }
      else if (role == CLMetabReferenceGlyph::ACTIVATOR)
        {
          glTranslatef(p2.getX(), p2.getY(), 0.0f);
          glRotatef(angle, 0.0f, 0.0f, 1.0f);
          glScalef(3.0f, 3.0f, 1.0f);
          glCallList(mDisplayLists + 6);
        }
      else if (role == CLMetabReferenceGlyph::INHIBITOR)
        {
          glTranslatef(p2.getX(), p2.getY(), 0.0f);
          glRotatef(angle, 0.0f, 0.0f, 1.0f);
          glScalef(3.0f, 3.0f, 1.0f);
          glCallList(mDisplayLists + 8);
        }
    }

  // reset the color since some of the call lists change the color
  glColor4fv(mSpeciesReferenceColor);
  glPopMatrix();
}

void CQGLNetworkPainter::drawColorLegend ( )

private

Definition at line 957 of file CQGLNetworkPainter.cpp.

References C_INT16, C_INT32, and RG_drawStringAt().

Referenced by drawGraph().

{
  C_INT32 sx = 40; //start at position (sx,sy)
  C_INT32 sy = 20;
  C_INT32 w = 120; // size of legend rectangle w x h
  C_INT32 h = 15;

  RG_drawStringAt("MIN", 7, sy + 3, 32, 16);
  RG_drawStringAt("MAX", 165, sy + 3, 32, 16);

  // the colors should go from RGB 0,0,0 to RGB 200,0,0 to RGB 200,200,0 to RGB
  // 255,255,0
  C_INT16 i;
  QColor col = QColor();
  // the color range has 456 steps and the legend has 120 pixels
  // so the step size is 455/120
  double ratio = 455 / 120;
  double val;

  for (i = 0; i <= w; i++)
    {
      val = i * ratio;

      if (val < 200.0)
        {
          col.setRgb(0, 0, (int)val);
        }
      else if (val < 400.0)
        {
          col.setRgb(0, (int)(val - 200.0), 200);
        }
      else
        {
          col.setRgb(0, 200 + (int)(val - 400.0), 200 + (int)(val - 400.0));
        }

      QGLWidget::qglColor(col);
      // draw colored line in rectangle
      glBegin(GL_LINES);
      glVertex2d(i + sx, sy);
      glVertex2d(i + sx, sy + h);
      glEnd();
    }
}

void CQGLNetworkPainter::drawEdge

(

CGraphCurve &

c

)

Definition at line 1340 of file CQGLNetworkPainter.cpp.

References drawArrow(), CGraphCurve::getArrow(), CLLineSegment::getBase1(), CLLineSegment::getBase2(), CLCurve::getCurveSegments(), CLLineSegment::getEnd(), CLCurve::getNumCurveSegments(), CGraphCurve::getRole(), CLLineSegment::getStart(), CLPoint::getX(), CLPoint::getY(), CGraphCurve::hasArrowP(), CLLineSegment::isBezier(), and SPECIESREFERENCE_DEPTH.

Referenced by drawGraph().

{
  glLineWidth(2.0);
  // Depth test has to be disabled when drawing lines,
  // especially if the lines have a thickness greater 1
  // otherwise they look ugly because break appear at the end of the lines and
  // they seem to be disconnected.
  // This seems to be a feature of OpenGL rather than a bug. (See
  // http://www.3dsource.de/faq/rasterization.htm)
  glDisable(GL_DEPTH_TEST);
  std::vector<CLLineSegment> segments = c.getCurveSegments();
  size_t i;

  for (size_t k = 0; k < c.getNumCurveSegments(); k++)
    {
      CLLineSegment seg = segments[k];

      CLPoint startPoint = seg.getStart();
      CLPoint endPoint = seg.getEnd();
      // for the moment do not take type of curve into account

      if (seg.isBezier())
        {
          CLPoint base1 = seg.getBase1();
          CLPoint base2 = seg.getBase2();
          //now paint Bezier as line strip
          // use an evaluator since this is probably a lot more efficient
          GLfloat controlPts[4][3] =
          {
            {static_cast<GLfloat>(startPoint.getX()), static_cast<GLfloat>(startPoint.getY()), SPECIESREFERENCE_DEPTH},
            {static_cast<GLfloat>(base1.getX()), static_cast<GLfloat>(base1.getY()), SPECIESREFERENCE_DEPTH},
            {static_cast<GLfloat>(base2.getX()), static_cast<GLfloat>(base2.getY()), SPECIESREFERENCE_DEPTH},
            {static_cast<GLfloat>(endPoint.getX()), static_cast<GLfloat>(endPoint.getY()), SPECIESREFERENCE_DEPTH}
          };
          // enable the evaluator to draw the cubic Bezier
          glMap1f(GL_MAP1_VERTEX_3, 0.0f, 20.0f, 3, 4, &controlPts[0][0]);
          glEnable(GL_MAP1_VERTEX_3);
          glBegin(GL_LINE_STRIP);

          for (i = 0; i <= 20; ++i)
            {
              // evaluate the function
              glEvalCoord1f((GLfloat)i);
            }

          glEnd();
          glDisable(GL_MAP1_VERTEX_3);
        }
      else
        {
          // just draw a straight line
          glBegin(GL_LINE_STRIP);
          glVertex3d(startPoint.getX(), startPoint.getY(), SPECIESREFERENCE_DEPTH);
          glVertex3d(endPoint.getX(), endPoint.getY(), SPECIESREFERENCE_DEPTH);
          glEnd();
        }
    }

  glLineWidth(1.0);

  if (c.hasArrowP())
    {
      drawArrow(c.getArrow(), c.getRole());
    }

  glEnable(GL_DEPTH_TEST);
}

void CQGLNetworkPainter::drawGraph

(

)

Definition at line 823 of file CQGLNetworkPainter.cpp.

References C_FLOAT64, C_INT32, CIRCLE, CVisParameters::COLOR_MODE, compartmentNodeMap, CVisParameters::DEFAULT_NODE_SIZE, drawColorLegend(), drawEdge(), drawNode(), CQLayoutMainWindow::getMappingMode(), getTextWidth(), mCurrentZoom, mf, mFontname, mFontsize, mLabelShape, mSpeciesReferenceColor, nodeCurveMap, nodeMap, pParentLayoutWindow, RECTANGLE, RG_drawStringAt(), viewerCompartmentNodes, viewerCurves, viewerLabels, and viewerNodes.

Referenced by draw(), export_bitmap(), mapLabelsToCircles(), mapLabelsToRectangles(), setFontSizeForLabels(), showStep(), and zoom().

{
  // create OpenGL display list
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  glLoadIdentity();
  unsigned int i;

  if ((pParentLayoutWindow != NULL) && this->mLabelShape == CIRCLE &&
      (pParentLayoutWindow->getMappingMode() == CVisParameters::COLOR_MODE)) // draw color legend
    {
      drawColorLegend();
    } // end color mode

  // draw curves to (reactant) nodes and arrows and circular nodes when in appropriate mode
  std::map<std::string, CCompartmentGraphNode>::iterator itCompartmentNode;
  std::map<std::string, CGraphNode>::iterator itNode;
  std::multimap<std::string, CGraphCurve>::iterator itCurve;
  std::multimap<std::string, CArrow>::iterator itArrow;
  std::pair<std::multimap<std::string, CGraphCurve>::iterator, std::multimap<std::string, CGraphCurve>::iterator> curveRangeIt;;
  std::pair<std::multimap<std::string, CArrow>::iterator, std::multimap<std::string, CArrow>::iterator> arrowRangeIt;

  for (i = 0; i < viewerCompartmentNodes.size(); i++)
    {
      itCompartmentNode = compartmentNodeMap.find(viewerCompartmentNodes[i]);

      // draw node as rectangle
      if (itCompartmentNode != compartmentNodeMap.end())
        {
          drawNode((*itCompartmentNode).second);
        }
    }

  for (i = 0; i < viewerNodes.size(); i++)
    {
      itNode = nodeMap.find(viewerNodes[i]);
      // draw curves of node
      curveRangeIt = nodeCurveMap.equal_range(viewerNodes[i]);
      itCurve = curveRangeIt.first;
      glColor4fv(mSpeciesReferenceColor);

      while (itCurve != curveRangeIt.second)
        {
          drawEdge((*itCurve).second);
          itCurve++;
        }

      //draw node as a circle
      if (itNode != nodeMap.end())
        {
          drawNode((*itNode).second);
        }
    }

  glColor4fv(mSpeciesReferenceColor);

  for (i = 0; i < viewerCurves.size(); i++) // draw edges that do not directly belong to a node (reaction curves)
    {
      drawEdge(viewerCurves[i]);
    }

  // NOW DRAW LABELS

  if (this->mLabelShape == RECTANGLE)
    {
      // debug: print font info
      this->mf.setPointSize(this->mFontsize);
      const QFont& mfRef = this->mf;
      QFontInfo fontInfo = QFontInfo(mfRef);

      // debug end
      for (i = 0; i < viewerLabels.size(); i++)
        {
          // only draw the text if there actually is text
          if (!viewerLabels[i].getText().empty())
            {
              RG_drawStringAt(viewerLabels[i].getText(), static_cast<C_INT32>(viewerLabels[i].getX()), static_cast<C_INT32>(viewerLabels[i].getY()), static_cast<C_INT32>(viewerLabels[i].getWidth()), static_cast<C_INT32>(viewerLabels[i].getHeight()));
            }
        }
    }
  else
    {
      // draw string next to circle (to the right) or in the center if there is enough space
      for (i = 0; i < viewerLabels.size(); i++)
        {
          if (!viewerLabels[i].getText().empty())
            {
              C_FLOAT64 tWid = getTextWidth(viewerLabels[i].getText(), mFontname, static_cast<int>(floor(viewerLabels[i].getHeight())));
              C_FLOAT64 nDiam = 0.0;
              C_FLOAT64 x, y;

              const std::string& nodeKey = viewerLabels[i].getGraphicalObjectKey();

              if (!nodeKey.empty())
                {
                  std::map<std::string, CGraphNode>::iterator itNodeObj;
                  itNodeObj = nodeMap.find(nodeKey);

                  if (itNodeObj != nodeMap.end())
                    nDiam = (*itNodeObj).second.getSize();

                  C_INT32 xNdCenter = (C_INT32)((*itNodeObj).second.getX() + ((*itNodeObj).second.getWidth() / 2.0));
                  C_INT32 yNdCenter = (C_INT32)(*itNodeObj).second.getY() + ((*itNodeObj).second.getHeight() / 2.0);

                  if (pParentLayoutWindow->getMappingMode() == CVisParameters::COLOR_MODE)
                    {
                      x = xNdCenter + (CVisParameters::DEFAULT_NODE_SIZE / 2.0 * this->mCurrentZoom) + 2.0 - ((viewerLabels[i].getWidth() - tWid) / 2.0); // node center + circle radius + 2.0 - texture window overhead
                      y = yNdCenter + (CVisParameters::DEFAULT_NODE_SIZE / 2.0 * this->mCurrentZoom) + 2.0 - ((viewerLabels[i].getHeight()) / 2.0);
                    }
                  else if ((tWid + 4) > nDiam)
                    {
                      // label wider (+ k=4 to avoid crossing circle borders) than size of circle-> place next to circle
                      x = xNdCenter + (nDiam / 2.0) + 2.0 - ((viewerLabels[i].getWidth() - tWid) / 2.0); // + nDiam / 2.0 - ((labelWWid - (*itNodeObj).second.getWidth()) / 2.0); // node center + circle radius - texture window overhead
                      y = yNdCenter + (nDiam / 2.0) + 2.0 - ((viewerLabels[i].getHeight()) / 2.0);
                    }
                  else
                    {
                      // place in center of circle
                      x = xNdCenter - (viewerLabels[i].getWidth() / 2.0); // - ((labelWWid - (*itNodeObj).second.getWidth()) / 2.0);
                      y = yNdCenter;
                    }
                }
              else
                {
                  // if there is no node associated, just take label position
                  x = viewerLabels[i].getX();
                  y = viewerLabels[i].getY();
                }

              RG_drawStringAt(viewerLabels[i].getText(), static_cast<C_INT32>(x), static_cast<C_INT32>(y), static_cast<C_INT32>(viewerLabels[i].getWidth()), static_cast<C_INT32>(viewerLabels[i].getHeight()));
            }
        }
    }
}

void CQGLNetworkPainter::drawNode

(

CCompartmentGraphNode &

n

)

Definition at line 1003 of file CQGLNetworkPainter.cpp.

References COMPARTMENT_SHADOW_DEPTH, CLGraphicalObject::getHeight(), CLGraphicalObject::getWidth(), CLGraphicalObject::getX(), CLGraphicalObject::getY(), mCompartmentShadowXOffset, mCompartmentShadowYOffset, mDisplayLists, mDrawShadows, and MIRROR_Y.

Referenced by drawGraph().

{
  float width = n.getWidth();
  float height = n.getHeight();
  float x = n.getX();
  float y = n.getY();
  float translateX = 0.0f;
  float scaledWidth = width - (0.2f * height);

  if (mDrawShadows == true)
    {
      // first we draw the shadow which we move a bit to the left and somewhat up
      // and into the correct depth
      glPushMatrix();
      // draw one end
      glLoadIdentity();
      glTranslatef(mCompartmentShadowXOffset, mCompartmentShadowYOffset, COMPARTMENT_SHADOW_DEPTH);
      translateX = x;
      glPushMatrix();
      // additional translation 0.1*width needed because we mirror the
      // element
      glTranslatef(translateX + height * 0.1, y, 0.0f);
      glScalef(height, height, 1.0f);
      // mirror it at the y axis
      glMultMatrixf(MIRROR_Y);
      glCallList(mDisplayLists + 11);
      glPopMatrix();
      // draw the center
      // scale it to the correct width
      translateX += 0.1 * height;
      glTranslatef(translateX, y, 0.0f);
      // the scaling has to be different
      glScalef(scaledWidth, height, 1.0f);
      glCallList(mDisplayLists + 12);
      // draw the other end
      glLoadIdentity();
      glTranslatef(mCompartmentShadowXOffset, mCompartmentShadowYOffset, COMPARTMENT_SHADOW_DEPTH);
      translateX += scaledWidth;
      glTranslatef(translateX, y, 0.0f);
      glScalef(height, height, 1.0f);
      glCallList(mDisplayLists + 11);
      // scale the object the the correct size
      glPopMatrix();
    }

  // now draw the real glyph
  glPushMatrix();
  // draw one end
  glLoadIdentity();
  translateX = x;
  glPushMatrix();
  // additional translation 0.1*width needed because we mirror the
  // element
  glTranslatef(translateX + height * 0.1, y, 0.0f);
  glScalef(height, height, 1.0f);
  // mirror it at the y axis
  glMultMatrixf(MIRROR_Y);
  glCallList(mDisplayLists + 1);
  glPopMatrix();
  // draw the center
  // scale it to the correct width
  translateX += 0.1 * height;
  glTranslatef(translateX, y, 0.0f);
  // the scaling has to be different
  glScalef(scaledWidth, height, 1.0f);
  glCallList(mDisplayLists + 2);
  // draw the other end
  glLoadIdentity();
  translateX += scaledWidth;
  glTranslatef(translateX, y, 0.0f);
  glScalef(height, height, 1.0f);
  glCallList(mDisplayLists + 1);
  // scale the object the the correct size
  glPopMatrix();
}

void CQGLNetworkPainter::drawNode

(

CGraphNode &

n

)

Definition at line 1080 of file CQGLNetworkPainter.cpp.

References CIRCLE, CVisParameters::DEFAULT_NODE_SIZE, CLGraphicalObject::getHeight(), CQLayoutMainWindow::getMappingMode(), CGraphNode::getOrigNodeKey(), CGraphNode::getSize(), CLGraphicalObject::getWidth(), CLGraphicalObject::getX(), CLGraphicalObject::getY(), mAnimatedSpeciesColor, mCirclePoints, mConstantSpeciesColor, mCurrentZoom, mDisplayLists, mDrawShadows, mFrameColor, MIRROR_Y, mLabelShape, mSpeciesShadowXOffset, mSpeciesShadowYOffset, pParentLayoutWindow, setOfConstantMetabolites, setOfDisabledMetabolites, CVisParameters::SIZE_AREA_MODE, CVisParameters::SIZE_DIAMETER_MODE, SPECIES_DEPTH, SPECIES_FRAME_DEPTH, and SPECIES_SHADOW_DEPTH.

{
  if (this->mLabelShape == CIRCLE)
    {
      float scaledValue = CVisParameters::DEFAULT_NODE_SIZE * mCurrentZoom;
      CVisParameters::MAPPING_MODE mappingMode = CVisParameters::SIZE_DIAMETER_MODE;

      if (pParentLayoutWindow != NULL)
        {
          mappingMode = pParentLayoutWindow->getMappingMode();

          if ((mappingMode == CVisParameters::SIZE_DIAMETER_MODE) ||
              (mappingMode == CVisParameters::SIZE_AREA_MODE))
            {
              scaledValue = n.getSize(); // change of node size only for size mode
            }
        }

      glColor4fv(mAnimatedSpeciesColor); // red

      double tx = n.getX() + (n.getWidth() / 2.0);
      double ty = n.getY() + (n.getHeight() / 2.0);

      if ((mappingMode == CVisParameters::SIZE_DIAMETER_MODE) ||
          (mappingMode == CVisParameters::SIZE_AREA_MODE))
        {
          if (setOfConstantMetabolites.find(n.getOrigNodeKey()) == setOfConstantMetabolites.end())
            {
              if (setOfDisabledMetabolites.find(n.getOrigNodeKey()) == setOfDisabledMetabolites.end())
                {
                  // red as default color for all nodes in non-color modes
                  // which have a substantial range of values (max - min > epsilon)
                  // and which are not disabled
                  if (mDrawShadows == true)
                    {
                      glPushMatrix();
                      glTranslatef(tx + mSpeciesShadowXOffset, ty + mSpeciesShadowYOffset, SPECIES_SHADOW_DEPTH);
                      glScalef(scaledValue, scaledValue, 1.0f);
                      glCallList(mDisplayLists + 16);
                      glPopMatrix();
                    }

                  glPushMatrix();
                  glTranslatef(tx, ty, 0.0f);
                  glScalef(scaledValue, scaledValue, 1.0f);
                  glCallList(mDisplayLists + 13);
                  glPopMatrix();
                }
              else
                {
                  scaledValue = CVisParameters::DEFAULT_NODE_SIZE; // default node size

                  if (mDrawShadows == true)
                    {
                      glPushMatrix();
                      glTranslatef(tx + mSpeciesShadowXOffset, ty + mSpeciesShadowYOffset, SPECIES_SHADOW_DEPTH);
                      glScalef(scaledValue, scaledValue, 1.0f);
                      glCallList(mDisplayLists + 16);
                      glPopMatrix();
                    }

                  glPushMatrix();
                  glTranslatef(tx, ty, 0.0f);
                  glScalef(scaledValue, scaledValue, 1.0f);
                  glCallList(mDisplayLists + 14);
                  glPopMatrix();
                }
            }
          else
            {
              scaledValue = CVisParameters::DEFAULT_NODE_SIZE; // node size for disabled nodes

              if (mDrawShadows == true)
                {
                  glPushMatrix();
                  glTranslatef(tx + mSpeciesShadowXOffset, ty + mSpeciesShadowYOffset, SPECIES_SHADOW_DEPTH);
                  glScalef(scaledValue, scaledValue, 1.0f);
                  glCallList(mDisplayLists + 16);
                  glPopMatrix();
                }

              glPushMatrix();
              glTranslatef(tx, ty, 0.0f);
              glScalef(scaledValue, scaledValue, 1.0f);
              glCallList(mDisplayLists + 15);
              glPopMatrix();
            }
        }
      // are not scaled and marked in grey
      else
        {
          // color mapping
          GLfloat color[3] = {1.0f, 1.0f, 1.0f};

          if (setOfConstantMetabolites.find(n.getOrigNodeKey()) == setOfConstantMetabolites.end())
            {
              if (setOfDisabledMetabolites.find(n.getOrigNodeKey()) == setOfDisabledMetabolites.end())
                {
                  float v = (float)n.getSize() * 455.0f; // there are 456 colors in the current gradient and the node sizes are scaled from 0.0 to 1.0 in color mode

                  if (v < 200.0)
                    {
                      color[0] = 0.0f;
                      color[1] = 0.0f;
                      color[2] = v / 255.0f;
                    }
                  else if (v < 400)
                    {
                      color[0] = 0.0f;
                      color[1] = (v - 200.0f) / 255.0f;
                      color[2] = 200.0f / 255.0f;
                    }
                  else
                    {
                      color[0] = 0.0f;
                      color[1] = (200.0f + (v - 400.0f)) / 255.0f;
                      color[2] = (200.0f + (v - 400.0f)) / 255.0f;
                    }
                }
              // is disabled
              else
                {
                  // set color to white
                  color[0] = 1.0f;
                  color[1] = 1.0f;
                  color[2] = 1.0f;
                }
            }
          // is constant
          else
            {
              // set color to light gray
              color[0] = mConstantSpeciesColor[0];
              color[1] = mConstantSpeciesColor[1];
              color[2] = mConstantSpeciesColor[2];
            }

          if (mDrawShadows == true)
            {
              glPushMatrix();
              glTranslatef(tx + mSpeciesShadowXOffset, ty + mSpeciesShadowYOffset, SPECIES_SHADOW_DEPTH);
              glScalef(scaledValue, scaledValue, 1.0f);
              glCallList(mDisplayLists + 16);
              glPopMatrix();
            }

          // use out own circle points to draw the circle instead of using glut
          // this makes it easier to have color gradients.
          glPushMatrix();
          glTranslatef((float)tx, (float)ty, 0.0f);
          glScalef(scaledValue, scaledValue, 1.0f);
          float lowerBound = 0.5;
          std::vector<std::pair<float, float> >::const_iterator it = mCirclePoints.begin(), endit = mCirclePoints.end();
          glBegin(GL_TRIANGLE_FAN);
          glColor3fv(color);
          glVertex3f(0.0f, 0.0f, SPECIES_DEPTH);
          // on the edge we have 50% of the color value
          glColor4f(color[0]*lowerBound, color[1]*lowerBound, color[2]*lowerBound, 1.0f);

          while (it != endit)
            {
              glVertex3f(it->first, it->second, SPECIES_DEPTH);
              ++it;
            }

          glEnd();
          glColor4fv(mFrameColor);
          glDisable(GL_DEPTH_TEST);
          it = mCirclePoints.begin();
          glBegin(GL_LINE_LOOP);

          while (it != endit)
            {
              glVertex3f(it->first, it->second, SPECIES_FRAME_DEPTH);
              ++it;
            }

          glEnd();
          glPopMatrix();
        }
    }
  else
    {
      float width = n.getWidth();
      float height = n.getHeight();
      float x = n.getX();
      float y = n.getY();
      float scaledWidth = width - (0.2f * height);
      float translateX = 0.0f;

      // first draw shadow if enabled
      if (mDrawShadows == true)
        {
          // first we draw the shadow which we move a bit to the left and somewhat up
          // and into the correct depth
          glPushMatrix();
          // draw one end
          glLoadIdentity();
          glTranslatef(mSpeciesShadowXOffset, mSpeciesShadowYOffset, SPECIES_SHADOW_DEPTH);
          translateX = x;
          glPushMatrix();
          // additional translation 0.1*width needed because we mirror the
          // element
          glTranslatef(translateX + height * 0.1, y, 0.0f);
          glScalef(height, height, 1.0f);
          // mirror it at the y axis
          glMultMatrixf(MIRROR_Y);
          glCallList(mDisplayLists + 11);
          glPopMatrix();
          // draw the center
          // scale it to the correct width
          translateX += 0.1 * height;
          glTranslatef(translateX, y, 0.0f);
          // the scaling has to be different
          glScalef(scaledWidth, height, 1.0f);
          glCallList(mDisplayLists + 12);
          // draw the other end
          glLoadIdentity();
          glTranslatef(mSpeciesShadowXOffset, mSpeciesShadowYOffset, SPECIES_SHADOW_DEPTH);
          translateX += scaledWidth;
          glTranslatef(translateX, y, 0.0f);
          glScalef(height, height, 1.0f);
          glCallList(mDisplayLists + 11);
          // scale the object the the correct size
          glPopMatrix();
        }

      // now draw the real glyph
      glPushMatrix();
      // draw one end
      glLoadIdentity();
      translateX = x;
      glPushMatrix();
      // additional translation 0.1*width needed because we mirror the
      // element
      glTranslatef(translateX + height * 0.1, y, 0.0f);
      glScalef(height, height, 1.0f);
      // mirror it at the y axis
      glMultMatrixf(MIRROR_Y);
      glCallList(mDisplayLists + 4);
      glPopMatrix();
      // draw the center
      // scale it to the correct width
      translateX += 0.1 * height;
      glTranslatef(translateX, y, 0.0f);
      // the scaling has to be different
      glScalef(scaledWidth, height, 1.0f);
      glCallList(mDisplayLists + 5);
      // draw the other end
      glLoadIdentity();
      translateX += scaledWidth;
      glTranslatef(translateX, y, 0.0f);
      glScalef(height, height, 1.0f);
      glCallList(mDisplayLists + 4);
      // scale the object the the correct size
      glPopMatrix();
    }
}

void CQGLNetworkPainter::drawStringAt ( std::string  s, C_FLOAT64  x, C_FLOAT64  y, C_FLOAT64  w, C_FLOAT64  h, QColor  bgCol  )

private

Definition at line 1745 of file CQGLNetworkPainter.cpp.

References FROM_UTF8, mf, mFontsize, mFontsizeDouble, mTextColor, and round2powN().

{
  glColor4fv(mTextColor); // black

  QString str(FROM_UTF8(s));

  QFontMetrics mfm = QFontMetrics(mf);
  QRect bbox = mfm.boundingRect(FROM_UTF8(s)); // bounding rectangle for text in certain size

  int w2 = round2powN(bbox.width()); // look for smallest w2 = 2^^k with n > w2
  int h2 = round2powN(bbox.height() + 2); // look for smallest h2 = 2^^k with n > h2

  while (h2 > h)
    {
      // reduce font size in order to avoid problems with size of texture image
      this->mFontsize--;
      this->mFontsizeDouble = (double) this->mFontsize;
      mf.setPointSize(this->mFontsize);
      const QFont& mfRef = mf;
      QFontMetrics mfm = QFontMetrics(mfRef);
      bbox = mfm.boundingRect(FROM_UTF8(s));
      w2 = round2powN(bbox.width());
      h2 = round2powN(bbox.height() + 2);
    }

  QRect c(0, 0, w2, h2);

  QPixmap pm(w2, h2);

  pm.fill(bgCol);
  QPainter painter2(&pm);
  painter2.setPen(Qt::black);
  painter2.setFont(mf);
  painter2.drawText(c, Qt::AlignCenter, FROM_UTF8(s));
  painter2.end();

  QImage img = pm.toImage();
  QImage timg = QGLWidget::convertToGLFormat(img);

  glTexImage2D(GL_TEXTURE_2D, 0, 3, timg.width(), timg.height(), 0,
               GL_RGBA, GL_UNSIGNED_BYTE, timg.bits());
  double xoff = (w - w2) / 2.0;
  double yoff = (h - h2) / 2.0;

  xoff = 0;
  yoff = 0;

  glRasterPos2f(x + xoff, y + h - yoff);
  glDrawPixels(w2, h2, GL_RGBA, GL_UNSIGNED_BYTE, timg.bits());
}

void CQGLNetworkPainter::endOfAnimationReached ( )

signal

Referenced by initializeGraphPainter(), and triggerAnimationStep().

bool CQGLNetworkPainter::export_bitmap	(	double	x,
		double	y,
		double	width,
		double	height,
		unsigned int	imageWidth,
		unsigned int	imageHeight,
		const QString &	filename,
		const std::vector< size_t >	frames
	)

New method for creating a bitmap from the animation window. This method uses QPainter, QImage and QGLFrameBufferObject to draw into a multisample buffer if availabel and if not, it will be single sample. This way the implementation should work on more computers. The image is rendered in tiles of size 128x128 which should be OK for even small frame buffers and it is a multiple of 2 which is compliant with older versions of OpenGL.

The methods get the region to be drawn and the size of the final image as parameters. In addition to that, the user can specify a vectir of frame numbers to be rendered. If no frame number is given, nothing is rendered. If a frame number is outside the range of valid frame numbers, the last frame is rendered. If the rendering was successfull, true is returned, otherwise false is returned.

Definition at line 3237 of file CQGLNetworkPainter.cpp.

References C_FLOAT64, drawGraph(), mCurrentPositionX, mCurrentPositionY, mCurrentZoom, mDataSets, resizeGL(), showStep(), and stepShown.

Referenced by CQLayoutMainWindow::saveImage().

{
  bool result = true;

  if (!filename.isEmpty() && !frames.empty())
    {
      // set busy cursor
      QCursor oldCursor = this->cursor();
      this->setCursor(Qt::WaitCursor);
      // create a progress bar
      QProgressDialog* pProgress = new QProgressDialog("image export", "Cancel", 0, 100, this);
      QImage* pImage = NULL;
      // make the OpenGL context current
      this->makeCurrent();
      // draw tiles of size 128x128
      const unsigned int tileSize = 128;
      unsigned int numColumns = imageWidth / tileSize;
      unsigned int numRows = imageHeight / tileSize;
      //  save state
      double oldZoom = this->mCurrentZoom;
      this->mCurrentZoom = 1.0;
      double oldX = this->mCurrentPositionX;
      double oldY = this->mCurrentPositionY;
      GLint oldViewport[4];
      bool frameSet = false;
      // remember the current step
      size_t oldStep = this->stepShown;
      glMatrixMode(GL_PROJECTION);
      glPushMatrix();
      glMatrixMode(GL_MODELVIEW);  // Select The Modelview Matrix
      glPushMatrix();
      glGetIntegerv(GL_VIEWPORT, oldViewport);
      // create QGLFrameBufferObject and QPainter that draws into the framebuffer
      QGLFramebufferObject fbo(tileSize, tileSize, QGLFramebufferObject::CombinedDepthStencil);
      //QPainter fbopainter;
      fbo.bind();

      // create an instance of QImage and a QPainter that draws into the image
      if (fbo.isValid() && fbo.isBound())
        {
          try
            {
              pImage = new QImage(imageWidth, imageHeight, QImage::Format_RGB888);
            }
          catch (...)
            {
              pImage = NULL;
              result = false;
            }

          if (pImage->isNull())
            {
              delete pImage;
              pImage = NULL;
              result = false;
            }

          if (pImage != NULL)
            {
              QPainter p;

              // set the viewport
              glViewport(0, 0, (GLint)tileSize, (GLint)tileSize);
              //
              std::vector<size_t>::const_iterator it = frames.begin(), endit = frames.end();
              std::set<size_t> s;
              // cap frame
              size_t frame;

              while (it != endit)
                {

                  frame = *it;

                  if (frame >= mDataSets.size())
                    {
                      if (this->mDataSets.empty())
                        {
                          frame = 0;
                        }
                      else
                        {
                          frame = this->mDataSets.size();
                        }
                    }

                  s.insert(frame);
                  ++it;
                }

              pProgress->setMaximum(s.size());
              pProgress->show();
              // loop over the frames
              std::set<size_t>::const_iterator sit = s.begin(), sendit = s.end();
              unsigned int step = 0;

              while (sit != sendit)
                {
                  // the tile size doesn't change because the texture
                  // in the framebuffer should by a multiple of 2
                  // When we copy the pixels for the potential stripes on the right
                  // and at the bottom, we have to consider this
                  GLdouble xPos = (GLdouble)x, yPos = (GLdouble)y, w = (GLdouble)(width * (double)tileSize / (double)imageWidth), h = (GLdouble)height * (double)tileSize / (double)imageHeight;

                  if (pProgress->wasCanceled())
                    {
                      break;
                    }

                  // for each iteration, we need to reset the frameSet flag
                  frameSet = false;
                  p.begin(pImage);
                  frame = *sit;
                  // loop overs the rows and columns and render the tiles
                  unsigned int i, j;

                  for (i = 0; i < numRows; ++i, yPos += h, xPos = (GLdouble)x)
                    {
                      for (j = 0; j < numColumns; ++j)
                        {
                          // set the projection
                          glMatrixMode(GL_PROJECTION);    // Select The Projection Matrix
                          glLoadIdentity();             // Reset The Projection Matrix
                          gluOrtho2D((GLdouble)xPos,
                                     (GLdouble)(xPos + w),
                                     (GLdouble)(yPos + h),
                                     (GLdouble)yPos); // y: 0.0 is bottom left instead of top left as in SBML
                          glMatrixMode(GL_MODELVIEW);  // Select The Modelview Matrix

                          // create the tile
                          // If the correct frame has already been set, we only need to redraw, otherwise we
                          // need to update the frames
                          if (!frameSet)
                            {
                              this->showStep(frame);
                              frameSet = true;
                            }
                          else
                            {
                              this->drawGraph();
                            }

                          // render it into the image
                          p.drawImage(QPoint(j * tileSize, i * tileSize), fbo.toImage());
                          xPos += w;
                        }

                      if (imageWidth % tileSize != 0)
                        {
                          // there is a stripe on the right
                          // set the projection
                          glMatrixMode(GL_PROJECTION);    // Select The Projection Matrix
                          glLoadIdentity();             // Reset The Projection Matrix
                          gluOrtho2D((GLdouble)xPos,
                                     (GLdouble)(xPos + w),
                                     (GLdouble)(yPos + h),
                                     (GLdouble)yPos); // y: 0.0 is bottom left instead of top left as in SBML
                          glMatrixMode(GL_MODELVIEW);  // Select The Modelview Matrix

                          // create the tile
                          if (!frameSet)
                            {
                              this->showStep(frame);
                              frameSet = true;
                            }
                          else
                            {
                              this->drawGraph();
                            }

                          // render part of tile into the image
                          p.drawImage(QPoint(j * tileSize, i * tileSize), fbo.toImage(), QRect(QPoint(0, 0), QSize(imageWidth % tileSize, tileSize)));
                        }
                    }

                  if ((imageHeight % tileSize) != 0)
                    {
                      // create the stripe at the bottom
                      for (j = 0; j < numColumns; ++j, xPos += w)
                        {
                          // set the projection
                          glMatrixMode(GL_PROJECTION);    // Select The Projection Matrix
                          glLoadIdentity();             // Reset The Projection Matrix
                          gluOrtho2D((GLdouble)xPos,
                                     (GLdouble)(xPos + w),
                                     (GLdouble)(yPos + h),
                                     (GLdouble)yPos); // y: 0.0 is bottom left instead of top left as in SBML
                          glMatrixMode(GL_MODELVIEW);  // Select The Modelview Matrix

                          // create the tile
                          if (!frameSet)
                            {
                              this->showStep(frame);
                              frameSet = true;
                            }
                          else
                            {
                              this->drawGraph();
                            }

                          // render part of tile into the image
                          p.drawImage(QPoint(j * tileSize, i * tileSize), fbo.toImage(), QRect(QPoint(0, 0), QSize(tileSize, imageHeight % tileSize)));
                        }

                      if (imageWidth % tileSize != 0)
                        {
                          // there is a stripe on the right
                          // set the projection
                          glMatrixMode(GL_PROJECTION);    // Select The Projection Matrix
                          glLoadIdentity();             // Reset The Projection Matrix
                          gluOrtho2D((GLdouble)xPos,
                                     (GLdouble)(xPos + w),
                                     (GLdouble)(yPos + h),
                                     (GLdouble)yPos); // y: 0.0 is bottom left instead of top left as in SBML
                          glMatrixMode(GL_MODELVIEW);  // Select The Modelview Matrix

                          // create the tile
                          if (!frameSet)
                            {
                              this->showStep(frame);
                              frameSet = true;
                            }
                          else
                            {
                              this->drawGraph();
                            }

                          // render part of tile into the image
                          p.drawImage(QPoint(j * tileSize, i * tileSize), fbo.toImage(), QRect(QPoint(0, 0), QSize(imageWidth % tileSize, imageHeight % tileSize)));
                        }
                    }

                  p.end();
                  // create a new temporary filename
                  QString tmpfilename;

                  if (frames.size() > 1)
                    {
                      // add the frame number to the frame name
                      QFileInfo info(filename);
                      QString completeBaseName = info.completeBaseName();
                      QString suffix = info.suffix();
                      QString path = info.path();
                      assert(suffix == "png" || suffix == "PNG");
                      tmpfilename = path;
                      tmpfilename.append("/");
                      tmpfilename.append(completeBaseName);
                      // check how many decimals we need
                      // the largest number should be at the end of s
                      int length = ceil(log10((C_FLOAT64) * s.rbegin()) + 1);
                      tmpfilename.append(QString("%1").arg((uint)frame, (int)length, (int)10, QLatin1Char('0')));
                      tmpfilename.append(".");
                      tmpfilename.append(suffix);
                    }
                  else
                    {
                      tmpfilename = filename;
                    }

                  // save the image
                  pImage->save(tmpfilename, "PNG");
                  ++sit;
                  ++step;
                  pProgress->setValue(step);
                  QCoreApplication::processEvents();
                }

              fbo.release();
              // Reset the state
              // First we have to return to the old step
              this->mCurrentZoom = oldZoom;
              this->mCurrentPositionX = oldX;
              this->mCurrentPositionY = oldY;
              // reset the projection
              glViewport(oldViewport[0], oldViewport[1], oldViewport[2], oldViewport[3]);
              glMatrixMode(GL_MODELVIEW);  // Select The Modelview Matrix
              glPopMatrix();
              glMatrixMode(GL_PROJECTION);
              glPopMatrix();

              if (oldStep != frame)
                {
                  this->setVisible(false);
                  this->showStep(oldStep);
                  this->setVisible(true);
                  this->resizeGL(oldViewport[2], oldViewport[3]);
                }
              else
                {
                  this->resizeGL(oldViewport[2], oldViewport[3]);
                }

              delete pImage;
            }
          else
            {
              fbo.release();
            }
        }
      else
        {
          result = false;
        }

      // reset cursor
      this->setCursor(oldCursor);
      pProgress->close();
      delete pProgress;
    }
  else
    {
      result = false;
    }

  // return the result;
  return result;
}

double CQGLNetworkPainter::fitToScreen

(

)

Calculates the ratio that is needed to fit the diagram on the current viewport and sets this as the zoom factor. The new zoom factor is returned.

Definition at line 3163 of file CQGLNetworkPainter.cpp.

References getGraphMax(), getGraphMin(), CLPoint::getX(), CLPoint::getY(), max, min, setCurrentPosition(), setZoomFactor(), and zoom().

Referenced by CQGLViewport::fitToScreen().

{
  double zoom = 1.0;
  const CLPoint& min = this->getGraphMin();
  const CLPoint& max = this->getGraphMax();
  double width = max.getX() - min.getX();
  double height = max.getY() - min.getY();
  GLint vp[4];
  glGetIntegerv(GL_VIEWPORT, vp);

  double wRatio = (vp[2] - vp[0]) / width;
  double hRatio = (vp[3] - vp[1]) / height;

  if (wRatio > hRatio)
    {
      zoom = hRatio;
    }
  else
    {
      zoom = wRatio;
    }

  this->setZoomFactor(zoom);
  this->setCurrentPosition(this->getGraphMin().getX(), this->getGraphMin().getY());
  return zoom;
}

C_FLOAT64 CQGLNetworkPainter::getCurrentPositionX

(

)

const

Definition at line 3142 of file CQGLNetworkPainter.cpp.

References mCurrentPositionX.

Referenced by CQLayoutMainWindow::saveImage().

{
  return this->mCurrentPositionX;
}

C_FLOAT64 CQGLNetworkPainter::getCurrentPositionY

(

)

const

Definition at line 3147 of file CQGLNetworkPainter.cpp.

References mCurrentPositionY.

Referenced by CQLayoutMainWindow::saveImage().

{
  return this->mCurrentPositionY;
}

size_t CQGLNetworkPainter::getCurrentStep

(

)

const

Definition at line 2209 of file CQGLNetworkPainter.cpp.

References stepShown.

Referenced by CQLayoutMainWindow::saveImage().

{
  return this->stepShown;
}

CDataEntity * CQGLNetworkPainter::getDataSetAt

(

size_t

stepNumber

)

Definition at line 2264 of file CQGLNetworkPainter.cpp.

References mDataSets.

Referenced by CQLayoutMainWindow::showStep().

{
  CDataEntity* pDataSet = NULL;

  if (stepNumber < mDataSets.size())
    {
      pDataSet = &(mDataSets[stepNumber]);
    }

  return pDataSet;
}

C_INT16 CQGLNetworkPainter::getFontSize ( )

inline

Definition at line 126 of file CQGLNetworkPainter.h.

References mFontsize.

Referenced by FontChooser::FontChooser(), and CQLayoutMainWindow::getFontSize().

{return mFontsize;}

const CLPoint & CQGLNetworkPainter::getGraphMax

(

)

Definition at line 562 of file CQGLNetworkPainter.cpp.

References mgraphMax.

Referenced by fitToScreen(), CQLayoutMainWindow::saveImage(), and CQGLViewport::updateScrollbars().

{
  const CLPoint& ma = mgraphMax;
  return ma;
}

const CLPoint & CQGLNetworkPainter::getGraphMin

(

)

Definition at line 556 of file CQGLNetworkPainter.cpp.

References mgraphMin.

Referenced by fitToScreen(), resetView(), CQLayoutMainWindow::saveImage(), CQGLViewport::slotHValueChanged(), CQGLViewport::slotVValueChanged(), and CQGLViewport::updateScrollbars().

{
  const CLPoint& mi = mgraphMin;
  return mi;
}

QImage CQGLNetworkPainter::getImage

(

)

Definition at line 2840 of file CQGLNetworkPainter.cpp.

{
  return this->grabFrameBuffer();
}

int CQGLNetworkPainter::getLabelWindowWidth ( int  width )

private

Definition at line 1614 of file CQGLNetworkPainter.cpp.

{
  int exponent = static_cast<int>(ceil(log2(width + 2.0)));

  if (exponent < 6)
    {
      exponent = 6;
    }

  width = static_cast<int>(pow(2.0, exponent + 1));
  return width;
}

std::string CQGLNetworkPainter::getNameForNodeKey

(

std::string

key

)

Definition at line 3037 of file CQGLNetworkPainter.cpp.

References nodeMap.

Referenced by CQLayoutMainWindow::insertValueTable(), and CQLayoutMainWindow::updateValueTable().

{
  std::string s = "UNKNOWN";
  std::map<std::string, CGraphNode>::iterator itNodeObj = nodeMap.find(key);

  if (itNodeObj != nodeMap.end())
    s = (*itNodeObj).second.getLabelText();

  return s;
}

std::string CQGLNetworkPainter::getNodeNameEntry

(

int

i

)

Definition at line 3048 of file CQGLNetworkPainter.cpp.

References viewerNodes.

Referenced by CQLayoutMainWindow::insertValueTable(), and CQLayoutMainWindow::updateValueTable().

{
  if (i < static_cast< int >(viewerNodes.size()))
    return viewerNodes[i];
  else
    return "";
}

size_t CQGLNetworkPainter::getNumberOfNodeEntries ( )

inline

Definition at line 104 of file CQGLNetworkPainter.h.

References viewerNodes.

{return viewerNodes.size();}

size_t CQGLNetworkPainter::getNumberOfSteps

(

)

const

Definition at line 2204 of file CQGLNetworkPainter.cpp.

References mDataSets.

Referenced by CQLayoutMainWindow::forwardAnimation(), CQLayoutMainWindow::loadData(), CQLayoutMainWindow::mapLabelsToCircles(), CQLayoutMainWindow::saveImage(), CQLayoutMainWindow::startAnimation(), CQLayoutMainWindow::stepForwardAnimation(), and triggerAnimationStep().

{
  return mDataSets.size();
}

CLPoint CQGLNetworkPainter::getPointNearCircle ( CLBoundingBox  r, CLPoint  p, C_INT16  d  )

private

Definition at line 2567 of file CQGLNetworkPainter.cpp.

References C_FLOAT64, CVisParameters::DEFAULT_NODE_SIZE, CLBoundingBox::getDimensions(), CLDimensions::getHeight(), CLBoundingBox::getPosition(), CLDimensions::getWidth(), CLPoint::getX(), CLPoint::getY(), CLPoint::setX(), and CLPoint::setY().

Referenced by adaptCurveForCircle().

{
  CLPoint center; // center of rectangle
  center.setX(r.getPosition().getX() + (r.getDimensions().getWidth() / 2.0));
  center.setY(r.getPosition().getY() + (r.getDimensions().getHeight() / 2.0));

  C_FLOAT64 distance = sqrt(((p.getX() - center.getX()) * (p.getX() - center.getX())) + ((p.getY() - center.getY()) * (p.getY() - center.getY())));

  C_FLOAT64 onPointX = center.getX() + ((p.getX() - center.getX()) / distance * ((CVisParameters::DEFAULT_NODE_SIZE / 2.0) + d));
  C_FLOAT64 onPointY = center.getY() + ((p.getY() - center.getY()) / distance * ((CVisParameters::DEFAULT_NODE_SIZE / 2.0) + d));

  return CLPoint(onPointX, onPointY);
}

CLPoint CQGLNetworkPainter::getPointOnCircle ( CLBoundingBox  r, CLPoint  p  )

private

Definition at line 2552 of file CQGLNetworkPainter.cpp.

References C_FLOAT64, CVisParameters::DEFAULT_NODE_SIZE, CLBoundingBox::getDimensions(), CLDimensions::getHeight(), CLBoundingBox::getPosition(), CLDimensions::getWidth(), CLPoint::getX(), CLPoint::getY(), CLPoint::setX(), and CLPoint::setY().

{
  CLPoint center; // center of rectangle
  center.setX(r.getPosition().getX() + (r.getDimensions().getWidth() / 2.0));
  center.setY(r.getPosition().getY() + (r.getDimensions().getHeight() / 2.0));

  C_FLOAT64 distance = sqrt(((p.getX() - center.getX()) * (p.getX() - center.getX())) + ((p.getY() - center.getY()) * (p.getY() - center.getY())));

  C_FLOAT64 onPointX = center.getX() + ((p.getX() - center.getX()) / distance * CVisParameters::DEFAULT_NODE_SIZE / 2.0);
  C_FLOAT64 onPointY = center.getY() + ((p.getY() - center.getY()) / distance * CVisParameters::DEFAULT_NODE_SIZE / 2.0);

  return CLPoint(onPointX, onPointY);
}

CLPoint CQGLNetworkPainter::getPointOnRectangle ( CLBoundingBox  r, CLPoint  p  )

private

Definition at line 2490 of file CQGLNetworkPainter.cpp.

References C_FLOAT64, CLBoundingBox::getDimensions(), CLDimensions::getHeight(), CLBoundingBox::getPosition(), CLDimensions::getWidth(), CLPoint::getX(), CLPoint::getY(), CLPoint::setX(), and CLPoint::setY().

Referenced by adaptCurveForRectangles().

{
  CLPoint onpoint;
  CLPoint q = r.getPosition();
  q.setX(r.getPosition().getX() + r.getDimensions().getWidth()); // q is now top right point of rectangle
  CLPoint center; // center of rectangle
  center.setX(r.getPosition().getX() + (r.getDimensions().getWidth() / 2.0));
  center.setY(r.getPosition().getY() + (r.getDimensions().getHeight() / 2.0)); //

  C_FLOAT64 qAngle = atan((q.getY() - center.getY()) / (q.getX() - center.getX()));
  C_FLOAT64 pAngle = atan((p.getY() - center.getY()) / (p.getX() - center.getX()));

  if (fabs(pAngle) < fabs(qAngle))
    {
      // intersection point is left or right side
      if (p.getX() > center.getX()) // right side
        onpoint = CLPoint(q.getX(), center.getY());
      else // left side
        onpoint = CLPoint(r.getPosition().getX(), center.getY());
    }
  else
    {
      //intersection point is top or bottom side
      if (p.getY() > center.getY()) // top side
        onpoint = CLPoint(center.getX(), r.getPosition().getY() + r.getDimensions().getHeight());
      else // bottom side
        onpoint = CLPoint(center.getX(), r.getPosition().getY());
    }

  return onpoint;
}

RGTextureSpec * CQGLNetworkPainter::getTextureForText ( const std::string &  text, const std::string &  fontName, unsigned int  fontSize  )

private

Definition at line 1651 of file CQGLNetworkPainter.cpp.

References labelTextureMap, and RG_createTextureForText().

Referenced by RG_drawStringAt().

{
  std::map<std::string, RGTextureSpec*>::iterator it;
  it = labelTextureMap.find(text);
  RGTextureSpec* texSpec = NULL;

  if (it != labelTextureMap.end())
    {
      texSpec = ((*it).second);
    }
  else
    {
      texSpec = RG_createTextureForText(text, fontName, fontSize);
      labelTextureMap.insert(std::pair<std::string, RGTextureSpec*>(text, texSpec));
    }

  return texSpec;
}

int CQGLNetworkPainter::getTextWidth ( const std::string &  text, const std::string &  fontName, unsigned int  fontSize  )

private

Definition at line 1603 of file CQGLNetworkPainter.cpp.

Referenced by drawGraph().

{
  QFont font(QString(fontName.c_str()), fontSize);
  QFontMetrics fontMetrics = QFontMetrics(font);

  QRect rect = fontMetrics.boundingRect(QString(text.c_str()));
  int width = rect.width();

  return width;
}

C_FLOAT64 CQGLNetworkPainter::getZoomFactor

(

)

const

Definition at line 3096 of file CQGLNetworkPainter.cpp.

References mCurrentZoom.

Referenced by CQLayoutMainWindow::saveImage(), CQGLViewport::slotHValueChanged(), CQGLViewport::slotVValueChanged(), and CQGLViewport::updateScrollbars().

{
  return this->mCurrentZoom;
}

void CQGLNetworkPainter::initializeDisplayLists ( )

protected

This method creates all display lists and sets the clear color. This should be called whenever a color is changed.

Definition at line 134 of file CQGLNetworkPainter.cpp.

References COMPARTMENT_DEPTH, COMPARTMENT_FRAME_DEPTH, mAnimatedSpeciesColor, mBackgroundColor, mCirclePoints, mCompartmentColor, mConstantSpeciesColor, mDisplayLists, mFrameColor, mInanimatedSpeciesColor, MIRROR_X, mShadowColor, mSpeciesColor, mSpeciesReferenceColor, SPECIES_DEPTH, SPECIES_FRAME_DEPTH, and SPECIESREFERENCE_DEPTH.

Referenced by initializeGL().

{
  glClearColor(mBackgroundColor[0], mBackgroundColor[1], mBackgroundColor[2], mBackgroundColor[3]);
  // convert the node into a display list that is created once and call once
  // for each node.
  // this might safe some cpu cycles, especially when the nodes get more fancy.
  this->mDisplayLists = glGenLists(17);
  // this list is for the rectangular nodes
  GLfloat compartmentColor_080[] = {mCompartmentColor[0] + (1.0f - mCompartmentColor[0]) * 0.8f, mCompartmentColor[1] + (1.0f - mCompartmentColor[1]) * 0.8f, mCompartmentColor[2] + (1.0f - mCompartmentColor[2]) * 0.8f};
  GLfloat speciesColor_080[] = {mSpeciesColor[0] + (1.0f - mSpeciesColor[0]) * 0.8f, mSpeciesColor[1] + (1.0f - mSpeciesColor[1]) * 0.8f, mSpeciesColor[2] + (1.0f - mSpeciesColor[2]) * 0.8f};
  glNewList(mDisplayLists, GL_COMPILE);
  // approximate a quarter circle by a triangle fan with 3 triangles
  glBegin(GL_TRIANGLE_FAN);
  glColor3fv(compartmentColor_080);
  glVertex3f(0.0f, 0.4f, COMPARTMENT_DEPTH);
  glColor3f(1.0f, 1.0f, 1.0f);
  glVertex3f(0.0f, 0.5f, COMPARTMENT_DEPTH);
  glColor3f(mCompartmentColor[0] + (1.0f - mCompartmentColor[0]) * 0.9f, mCompartmentColor[1] + (1.0f - mCompartmentColor[1]) * 0.9f, mCompartmentColor[2] + (1.0f - mCompartmentColor[2]) * 0.9f); // 90% value
  glVertex3f(0.05f, 0.4866f, COMPARTMENT_DEPTH);
  glColor3f(mCompartmentColor[0] + (1.0f - mCompartmentColor[0]) * 0.973f, mCompartmentColor[1] + (1.0f - mCompartmentColor[1]) * 0.973f, mCompartmentColor[2] + (1.0f - mCompartmentColor[2]) * 0.973f); // 97.32% value
  glVertex3f(0.0866f, 0.45f, COMPARTMENT_DEPTH);
  glColor3fv(compartmentColor_080);
  glVertex3f(0.1f, 0.4f, COMPARTMENT_DEPTH);
  glEnd();
  glBegin(GL_POLYGON);
  glColor3fv(compartmentColor_080);
  glVertex3f(0.0f, 0.4f, COMPARTMENT_DEPTH);
  glVertex3f(0.1f, 0.4f, COMPARTMENT_DEPTH);
  glColor3fv(mCompartmentColor);
  glVertex3f(0.1f, 0.0f, COMPARTMENT_DEPTH);
  glVertex3f(0.0f, 0.0f, COMPARTMENT_DEPTH);
  glEnd();
  glColor4fv(mFrameColor);
  glLineWidth(1.0f);
  // raise the line strip a bit to circumvent clipping errors
  glDisable(GL_DEPTH_TEST);
  glBegin(GL_LINE_STRIP);
  glVertex3f(0.0f, 0.5f, COMPARTMENT_FRAME_DEPTH);
  glVertex3f(0.05f, 0.4866f, COMPARTMENT_FRAME_DEPTH);
  glVertex3f(0.0866f, 0.45f, COMPARTMENT_FRAME_DEPTH);
  glVertex3f(0.1f, 0.4f, COMPARTMENT_FRAME_DEPTH);
  glVertex3f(0.1f, 0.0f, COMPARTMENT_FRAME_DEPTH);
  glEnd();
  glEnable(GL_DEPTH_TEST);
  glEndList();

  // now copy the first call list and mirror the copy at the x-axis
  glNewList(mDisplayLists + 1, GL_COMPILE);
  glPushMatrix();
  glTranslatef(0.0f, 0.5f, 0.0f);
  glCallList(mDisplayLists);
  // mirror transformation
  glMultMatrixf(MIRROR_X);
  glCallList(mDisplayLists);
  glPopMatrix();
  glEndList();

  // next list is the center piece for the compartment glyph
  glNewList(mDisplayLists + 2, GL_COMPILE);
  glBegin(GL_POLYGON);
  glColor3f(1.0f, 1.0f, 1.0f);
  glVertex3f(0.0f, 1.0f, COMPARTMENT_DEPTH);
  glVertex3f(1.0f, 1.0f, COMPARTMENT_DEPTH);
  glColor3fv(mCompartmentColor);
  glVertex3f(1.0f, 0.5f, COMPARTMENT_DEPTH);
  glVertex3f(0.0f, 0.5f, COMPARTMENT_DEPTH);
  glEnd();
  glBegin(GL_POLYGON);
  glColor3fv(mCompartmentColor);
  glVertex3f(0.0f, 0.5f, COMPARTMENT_DEPTH);
  glVertex3f(1.0f, 0.5f, COMPARTMENT_DEPTH);
  glColor3f(1.0f, 1.0f, 1.0f);
  glVertex3f(1.0f, 0.0f, COMPARTMENT_DEPTH);
  glVertex3f(0.0f, 0.0f, COMPARTMENT_DEPTH);
  glEnd();
  glColor4fv(mFrameColor);
  glLineWidth(1.0f);
  // raise the lines  a bit to circumvent clipping errors
  glDisable(GL_DEPTH_TEST);
  glBegin(GL_LINES);
  glVertex3f(0.0f, 1.0f, COMPARTMENT_FRAME_DEPTH);
  glVertex3f(1.0f, 1.0f, COMPARTMENT_FRAME_DEPTH);
  glVertex3f(0.0f, 0.0f, COMPARTMENT_FRAME_DEPTH);
  glVertex3f(1.0f, 0.0f, COMPARTMENT_FRAME_DEPTH);
  glEnd();
  glEnable(GL_DEPTH_TEST);
  glEndList();

  // call lists for the species nodes
  glNewList(mDisplayLists + 3, GL_COMPILE);
  // approximate a quarter circle by a triangle fan with 3 triangles
  glBegin(GL_TRIANGLE_FAN);
  glColor3fv(speciesColor_080);
  glVertex3f(0.0f, 0.4f, SPECIES_DEPTH);
  glColor3f(1.0f, 1.0f, 1.0f);
  glVertex3f(0.0f, 0.5f, SPECIES_DEPTH);
  glColor3f(mSpeciesColor[0] + (1.0f - mSpeciesColor[0]) * 0.9f, mSpeciesColor[1] + (1.0f - mSpeciesColor[1]) * 0.9f, mSpeciesColor[2] + (1.0f - mSpeciesColor[2]) * 0.9f); // 90% value
  glVertex3f(0.05f, 0.4866f, SPECIES_DEPTH);
  glColor3f(mSpeciesColor[0] + (1.0f - mSpeciesColor[0]) * 0.973f, mSpeciesColor[1] + (1.0f - mSpeciesColor[1]) * 0.973f, mSpeciesColor[2] + (1.0f - mSpeciesColor[2]) * 0.973f); // 97.32% value
  glVertex3f(0.0866f, 0.45f, SPECIES_DEPTH);
  glColor3fv(speciesColor_080);
  glVertex3f(0.1f, 0.4f, SPECIES_DEPTH);
  glEnd();
  glBegin(GL_POLYGON);
  glColor3fv(speciesColor_080);
  glVertex3f(0.0f, 0.4f, SPECIES_DEPTH);
  glVertex3f(0.1f, 0.4f, SPECIES_DEPTH);
  glColor4fv(mSpeciesColor);
  glVertex3f(0.1f, 0.0f, SPECIES_DEPTH);
  glVertex3f(0.0f, 0.0f, SPECIES_DEPTH);
  glEnd();
  glColor4fv(mFrameColor);
  glLineWidth(1.0f);
  // raise the line strip a bit to circumvent clipping errors
  glDisable(GL_DEPTH_TEST);
  glBegin(GL_LINE_STRIP);
  glVertex3f(0.0f, 0.5f, SPECIES_FRAME_DEPTH);
  glVertex3f(0.05f, 0.4866f, SPECIES_FRAME_DEPTH);
  glVertex3f(0.0866f, 0.45f, SPECIES_FRAME_DEPTH);
  glVertex3f(0.1f, 0.4f, SPECIES_FRAME_DEPTH);
  glVertex3f(0.1f, 0.0f, SPECIES_FRAME_DEPTH);
  glEnd();
  glEnable(GL_DEPTH_TEST);
  glEndList();

  // now copy the first call list and mirror the copy at the x-axis
  glNewList(mDisplayLists + 4, GL_COMPILE);
  glPushMatrix();
  glTranslatef(0.0f, 0.5f, 0.0f);
  glCallList(mDisplayLists + 3);
  // mirror transformation
  glMultMatrixf(MIRROR_X);
  glCallList(mDisplayLists + 3);
  glPopMatrix();
  glEndList();

  // next list is the center piece for the species glyph
  glNewList(mDisplayLists + 5, GL_COMPILE);
  glBegin(GL_POLYGON);
  glColor3f(1.0f, 1.0f, 1.0f);
  glVertex3f(0.0f, 1.0f, SPECIES_DEPTH);
  glVertex3f(1.0f, 1.0f, SPECIES_DEPTH);
  glColor3fv(mSpeciesColor);
  glVertex3f(1.0f, 0.5f, SPECIES_DEPTH);
  glVertex3f(0.0f, 0.5f, SPECIES_DEPTH);
  glEnd();
  glBegin(GL_POLYGON);
  glColor3fv(mSpeciesColor);
  glVertex3f(0.0f, 0.5f, SPECIES_DEPTH);
  glVertex3f(1.0f, 0.5f, SPECIES_DEPTH);
  glColor3f(1.0f, 1.0f, 1.0f);
  glVertex3f(1.0f, 0.0f, SPECIES_DEPTH);
  glVertex3f(0.0f, 0.0f, SPECIES_DEPTH);
  glEnd();
  glColor4fv(mFrameColor);
  glLineWidth(1.0f);
  // raise the lines  a bit to circumvent clipping errors
  glDisable(GL_DEPTH_TEST);
  glBegin(GL_LINES);
  glVertex3f(0.0f, 1.0f, SPECIES_FRAME_DEPTH);
  glVertex3f(1.0f, 1.0f, SPECIES_FRAME_DEPTH);
  glVertex3f(0.0f, 0.0f, SPECIES_FRAME_DEPTH);
  glVertex3f(1.0f, 0.0f, SPECIES_FRAME_DEPTH);
  glEnd();
  glEnable(GL_DEPTH_TEST);
  glEndList();

  // display lists for arrow heads (try to be SBGN like)

  // head for stimulation (unfilled arrow)
  glNewList(mDisplayLists + 6, GL_COMPILE);
  glColor4fv(mBackgroundColor);
  glBegin(GL_POLYGON);
  glVertex3f(0.0f, 0.0f, SPECIESREFERENCE_DEPTH);
  glVertex3f(2.0f, -5.0f, SPECIESREFERENCE_DEPTH);
  glVertex3f(0.0f, -3.0f, SPECIESREFERENCE_DEPTH);
  glVertex3f(-2.0f, -5.0f, SPECIESREFERENCE_DEPTH);
  glEnd();
  glDisable(GL_DEPTH_TEST);
  glLineWidth(2.0f);
  glColor4fv(mSpeciesReferenceColor);
  glBegin(GL_LINE_LOOP);
  glVertex3f(0.0f, 0.0f, SPECIESREFERENCE_DEPTH);
  glVertex3f(2.0f, -5.0f, SPECIESREFERENCE_DEPTH);
  glVertex3f(0.0f, -3.0f, SPECIESREFERENCE_DEPTH);
  glVertex3f(-2.0f, -5.0f, SPECIESREFERENCE_DEPTH);
  glEnd();
  glLineWidth(1.0f);
  glEnable(GL_DEPTH_TEST);
  glEndList();

  // head for transition (filled arrow head)
  glNewList(mDisplayLists + 7, GL_COMPILE);
  glBegin(GL_POLYGON);
  glVertex3f(0.0f, 0.0f, SPECIESREFERENCE_DEPTH);
  glVertex3f(2.0f, -5.0f, SPECIESREFERENCE_DEPTH);
  glVertex3f(0.0f, -3.0f, SPECIESREFERENCE_DEPTH);
  glVertex3f(-2.0f, -5.0f, SPECIESREFERENCE_DEPTH);
  glEnd();
  glEndList();

  // head for inhibition (perpendicular bar)
  glNewList(mDisplayLists + 8, GL_COMPILE);
  glBegin(GL_POLYGON);
  glVertex3f(-3.0f, 0.5f, SPECIESREFERENCE_DEPTH);
  glVertex3f(3.0f, 0.5f, SPECIESREFERENCE_DEPTH);
  glVertex3f(3.0f, -0.5f, SPECIESREFERENCE_DEPTH);
  glVertex3f(-3.0f, -0.5f, SPECIESREFERENCE_DEPTH);
  glEnd();
  glEndList();

  // head for modulation (unfilled diamond)
  glNewList(mDisplayLists + 9, GL_COMPILE);
  glColor4fv(mBackgroundColor);
  glBegin(GL_POLYGON);
  glVertex3f(0.0f, 0.0f, SPECIESREFERENCE_DEPTH);
  glVertex3f(2.0f, -3.0f, SPECIESREFERENCE_DEPTH);
  glVertex3f(0.0f, -6.0f, SPECIESREFERENCE_DEPTH);
  glVertex3f(-2.0f, -3.0f, SPECIESREFERENCE_DEPTH);
  glEnd();
  glDisable(GL_DEPTH_TEST);
  glColor4fv(mSpeciesReferenceColor);
  glLineWidth(2.0f);
  glBegin(GL_LINE_LOOP);
  glVertex3f(0.0f, 0.0f, SPECIESREFERENCE_DEPTH);
  glVertex3f(2.0f, -3.0f, SPECIESREFERENCE_DEPTH);
  glVertex3f(0.0f, -6.0f, SPECIESREFERENCE_DEPTH);
  glVertex3f(-2.0f, -3.0f, SPECIESREFERENCE_DEPTH);
  glEnd();
  glLineWidth(1.0f);
  glEnable(GL_DEPTH_TEST);
  glEndList();

  // display lists for the shadows of the glyphs
  glNewList(mDisplayLists + 10, GL_COMPILE);
  // approximate a quarter circle by a triangle fan with 3 triangles
  glColor4fv(mShadowColor);
  glBegin(GL_TRIANGLE_FAN);
  glVertex3f(0.0f, 0.4f, 0.0f);
  glVertex3f(0.0f, 0.5f, 0.0f);
  glVertex3f(0.05f, 0.4866f, 0.0f);
  glVertex3f(0.0866f, 0.45f, 0.0f);
  glVertex3f(0.1f, 0.4f, 0.0f);
  glEnd();
  glBegin(GL_POLYGON);
  glVertex3f(0.0f, 0.4f, 0.0f);
  glVertex3f(0.1f, 0.4f, 0.0f);
  glVertex3f(0.1f, 0.0f, 0.0f);
  glVertex3f(0.0f, 0.0f, 0.0f);
  glEnd();
  glEndList();
  // now copy the first call list and mirror the copy at the x-axis
  glNewList(mDisplayLists + 11, GL_COMPILE);
  glPushMatrix();
  glTranslatef(0.0f, 0.5f, 0.0f);
  glCallList(mDisplayLists + 10);
  // mirror transformation
  glMultMatrixf(MIRROR_X);
  glCallList(mDisplayLists + 10);
  glPopMatrix();
  glEndList();
  // next list is the center piece for the shadow
  glNewList(mDisplayLists + 12, GL_COMPILE);
  glColor4fv(mShadowColor);
  glBegin(GL_POLYGON);
  glVertex3f(0.0f, 1.0f, 0.0f);
  glVertex3f(1.0f, 1.0f, 0.0f);
  glVertex3f(1.0f, 0.0f, 0.0f);
  glVertex3f(0.0f, 0.0f, 0.0f);
  glEnd();
  glEndList();

  // display list to draw a circle with a triangle fan for the animated species
  glNewList(mDisplayLists + 13, GL_COMPILE);
  float lowerBound = 0.5;
  std::vector<std::pair<float, float> >::const_iterator it = mCirclePoints.begin(), endit = mCirclePoints.end();
  glBegin(GL_TRIANGLE_FAN);
  glColor4fv(mAnimatedSpeciesColor);
  glVertex3f(0.0f, 0.0f, SPECIES_DEPTH);
  // on the edge we have 50% of the color value
  glColor4f(mAnimatedSpeciesColor[0]*lowerBound, mAnimatedSpeciesColor[1]*lowerBound, mAnimatedSpeciesColor[2]*lowerBound, 1.0f);

  while (it != endit)
    {
      glVertex3f(it->first, it->second, SPECIES_DEPTH);
      ++it;
    }

  glEnd();
  glColor4fv(mFrameColor);
  glDisable(GL_DEPTH_TEST);
  it = mCirclePoints.begin();
  glBegin(GL_LINE_LOOP);

  while (it != endit)
    {
      glVertex3f(it->first, it->second, SPECIES_FRAME_DEPTH);
      ++it;
    }

  glEnd();
  glEnable(GL_DEPTH_TEST);
  glEndList();

  // gray circle with color gradient for deactivated species in animation
  glNewList(mDisplayLists + 14, GL_COMPILE);
  lowerBound = 0.5;
  it = mCirclePoints.begin(), endit = mCirclePoints.end();
  glBegin(GL_TRIANGLE_FAN);
  glColor4fv(mInanimatedSpeciesColor);
  glVertex3f(0.0f, 0.0f, SPECIES_DEPTH);
  // on the edge we have 50% of the color value
  glColor4f(mInanimatedSpeciesColor[0]*lowerBound, mInanimatedSpeciesColor[1]*lowerBound, mInanimatedSpeciesColor[2]*lowerBound, 1.0f);

  while (it != endit)
    {
      glVertex3f(it->first, it->second, SPECIES_DEPTH);
      ++it;
    }

  glEnd();
  glColor4fv(mFrameColor);
  glDisable(GL_DEPTH_TEST);
  it = mCirclePoints.begin();
  glBegin(GL_LINE_LOOP);

  while (it != endit)
    {
      glVertex3f(it->first, it->second, SPECIES_FRAME_DEPTH);
      ++it;
    }

  glEnd();
  glEnable(GL_DEPTH_TEST);
  glEndList();

  // gray circle for constant nodes in animation
  glNewList(mDisplayLists + 15, GL_COMPILE);
  lowerBound = 0.5;
  it = mCirclePoints.begin(), endit = mCirclePoints.end();
  glBegin(GL_TRIANGLE_FAN);
  glColor4fv(mConstantSpeciesColor);
  glVertex3f(0.0f, 0.0f, SPECIES_DEPTH);
  // on the edge we have 50% of the color value
  glColor4f(mConstantSpeciesColor[0]*lowerBound, mConstantSpeciesColor[1]*lowerBound, mConstantSpeciesColor[2]*lowerBound, 1.0f);

  while (it != endit)
    {
      glVertex3f(it->first, it->second, SPECIES_DEPTH);
      ++it;
    }

  glEnd();
  glColor4fv(mFrameColor);
  glDisable(GL_DEPTH_TEST);
  it = mCirclePoints.begin();
  glBegin(GL_LINE_LOOP);

  while (it != endit)
    {
      glVertex3f(it->first, it->second, SPECIES_FRAME_DEPTH);
      ++it;
    }

  glEnd();
  glEnable(GL_DEPTH_TEST);
  glEndList();

  // gray circle with transparency for circle shadows
  glNewList(mDisplayLists + 16, GL_COMPILE);
  it = mCirclePoints.begin(), endit = mCirclePoints.end();
  glBegin(GL_TRIANGLE_FAN);
  glColor4fv(mShadowColor);
  glVertex3f(0.0f, 0.0f, 0.0f);

  while (it != endit)
    {
      glVertex3f(it->first, it->second, 0.0f);
      ++it;
    }

  glEnd();
  glEndList();
}

void CQGLNetworkPainter::initializeGL ( )

protected

Definition at line 519 of file CQGLNetworkPainter.cpp.

References initializeDisplayLists(), mIsInitialized, and textureNames.

{
  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  glEnable(GL_DEPTH_TEST);
  glEnable(GL_BLEND);
  glEnable(GL_LINE_SMOOTH);
  glEnable(GL_ALPHA_TEST);
  // glEnable(GL_POINT_SMOOTH);
  // glEnable(GL_POLYGON_SMOOTH);
  glShadeModel(GL_SMOOTH);

  glGenTextures(1, textureNames);
  this->initializeDisplayLists();
  mIsInitialized = true;
}

void CQGLNetworkPainter::initializeGraphPainter ( QWidget *  viewportWidget )

protected

Definition at line 2908 of file CQGLNetworkPainter.cpp.

References calculateCirclePoints(), createActions(), endOfAnimationReached(), FROM_UTF8, CVisParameters::INDIVIDUAL_SCALING, mAnimatedSpeciesColor, mBackgroundColor, mCirclePoints, mCompartmentColor, mCompartmentShadowXOffset, mCompartmentShadowYOffset, mConstantSpeciesColor, mCurrentPositionX, mCurrentPositionY, mCurrentZoom, mDataPresentP, mDrawShadows, mf, mFontname, mFontsize, mFontsizeDouble, mFrameColor, mgraphMax, mgraphMin, mInanimatedSpeciesColor, mLabelShape, mNumCirclePoints, mScaleMode, mShadowColor, mSpeciesColor, mSpeciesReferenceColor, mSpeciesShadowXOffset, mSpeciesShadowYOffset, mTextColor, pParentLayoutWindow, preserveMinLabelHeightP, RECTANGLE, regularTimer, stepChanged(), stepShown, and triggerAnimationStep().

Referenced by CQGLNetworkPainter().

{
  mScaleMode = CVisParameters::INDIVIDUAL_SCALING;

  mSpeciesColor[0] = 0.824f;
  mSpeciesColor[1] = 0.824f;
  mSpeciesColor[2] = 0.902f;
  mSpeciesColor[3] = 1.0f;

  mCompartmentColor[0] = 0.737f;
  mCompartmentColor[1] = 0.792f;
  mCompartmentColor[2] = 0.729f;
  mCompartmentColor[3] = 1.0f;

  mShadowColor[0] = 0.2f;
  mShadowColor[1] = 0.2f;
  mShadowColor[2] = 0.2f;
  mShadowColor[3] = 0.6f;

  mSpeciesReferenceColor[0] = 0.3f;
  mSpeciesReferenceColor[1] = 0.3f;
  mSpeciesReferenceColor[2] = 0.3f;
  mSpeciesReferenceColor[3] = 1.0f;

  mTextColor[0] = 0.0f;
  mTextColor[1] = 0.0f;
  mTextColor[2] = 0.0f;
  mTextColor[3] = 1.0f;

  mFrameColor[0] = 0.1f;
  mFrameColor[1] = 0.1f;
  mFrameColor[2] = 0.1f;
  mFrameColor[3] = 1.0f;

  mBackgroundColor[0] = 1.0f;
  mBackgroundColor[1] = 1.0f;
  mBackgroundColor[2] = 1.0f;
  mBackgroundColor[3] = 1.0f;

  mAnimatedSpeciesColor[0] = 1.0f;
  mAnimatedSpeciesColor[1] = 0.0f;
  mAnimatedSpeciesColor[2] = 0.0f;
  mAnimatedSpeciesColor[3] = 1.0f;

  mInanimatedSpeciesColor[0] = 0.75f;
  mInanimatedSpeciesColor[1] = 0.75f;
  mInanimatedSpeciesColor[2] = 1.0f;
  mInanimatedSpeciesColor[3] = 1.0f;

  mConstantSpeciesColor[0] = 0.7f;
  mConstantSpeciesColor[1] = 0.7f;
  mConstantSpeciesColor[2] = 0.7f;
  mConstantSpeciesColor[3] = 1.0f;

  mCompartmentShadowXOffset = 3.0f;
  mCompartmentShadowYOffset = 3.0f;

  // the species probably need a smaller shadow offset
  mSpeciesShadowXOffset = 2.0f;
  mSpeciesShadowYOffset = 2.0f;

  mDrawShadows = true;

  mNumCirclePoints = 30;
  mCirclePoints = calculateCirclePoints(mNumCirclePoints);

  std::vector<std::pair<float, float> > mCirclePoints;

  mCurrentZoom = 1.0;
  mCurrentPositionX = 0.0;
  mCurrentPositionY = 0.0;
  mLabelShape = RECTANGLE;
  mgraphMin = CLPoint(0.0, 0.0);
  mgraphMax = CLPoint(250.0, 250.0);
  //mFontname = "Helvetica";
  mFontname = "Arial";
  mFontsize = 12;
  mFontsizeDouble = 12.0; // to avoid rounding errors due to zooming in and out
  mDataPresentP = false;
  preserveMinLabelHeightP = true;

  mf = QFont(FROM_UTF8(mFontname));
  mf.setPointSize(this->mFontsize);
  const QFont& mfRef = mf;
  QFontMetrics mfm = QFontMetrics(mfRef);

  // parent structure: glPainter -> CQGLViewport -> splitter ->
  // vbox -> mainWindow
  QWidget *ancestor = parent->parentWidget();

  while (ancestor && dynamic_cast<CQLayoutMainWindow*>(ancestor) == NULL)
    {
      ancestor = ancestor->parentWidget();
    }

  assert(ancestor != NULL);
  connect(this, SIGNAL(stepChanged(int)), ancestor, SLOT(changeStepValue(int)));
  connect(this, SIGNAL(endOfAnimationReached()), ancestor, SLOT(endOfAnimationReached()));
  regularTimer = new QTimer(this);
  connect(regularTimer, SIGNAL(timeout()), this, SLOT(triggerAnimationStep()));

  CQLayoutMainWindow * tmp = dynamic_cast<CQLayoutMainWindow *>(ancestor);
  assert(tmp);

  if (tmp)
    pParentLayoutWindow = tmp;
  else
    pParentLayoutWindow = NULL;

  stepShown = 0;
  createActions();
}

bool CQGLNetworkPainter::isCircleMode

(

)

Definition at line 2896 of file CQGLNetworkPainter.cpp.

References CIRCLE, and mLabelShape.

Referenced by CQGLViewport::isCircleMode(), and CQLayoutMainWindow::loadData().

{
  if (this->mLabelShape == CIRCLE)
    {
      return true;
    }
  else
    {
      return false;
    }
}

void CQGLNetworkPainter::mapLabelsToCircles

(

)

Definition at line 2522 of file CQGLNetworkPainter.cpp.

References adaptCurveForCircle(), CIRCLE, drawGraph(), mLabelShape, nodeArrowMap, nodeCurveMap, nodeMap, and viewerNodes.

Referenced by CQLayoutMainWindow::mapLabelsToCircles().

{
  this->mLabelShape = CIRCLE;

  nodeArrowMap.clear(); // map is filled with new arrows
  std::pair<std::multimap<std::string, CGraphCurve>::iterator, std::multimap<std::string, CGraphCurve>::iterator> rangeCurveIt;
  std::multimap<std::string, CGraphCurve>::iterator curveIt;
  unsigned int i;

  for (i = 0; i < viewerNodes.size(); i++)
    {
      rangeCurveIt = nodeCurveMap.equal_range(viewerNodes[i]);
      std::map<std::string, CGraphNode>::iterator nodeIt = nodeMap.find(viewerNodes[i]); // find all edges belonging to a node

      if (nodeIt != nodeMap.end())
        {
          curveIt = rangeCurveIt.first;

          while (curveIt != rangeCurveIt.second)
            {
              this->adaptCurveForCircle(curveIt, (*nodeIt).second.getBoundingBox());
              curveIt++;
            }
        }
    }

  this->drawGraph();
}

void CQGLNetworkPainter::mapLabelsToRectangles

(

)

Definition at line 2462 of file CQGLNetworkPainter.cpp.

References adaptCurveForRectangles(), drawGraph(), mLabelShape, nodeArrowMap, nodeCurveMap, nodeMap, RECTANGLE, and viewerNodes.

Referenced by CQLayoutMainWindow::mapLabelsToRectangles().

{
  this->mLabelShape = RECTANGLE;
  nodeArrowMap.clear(); // map is filled with new arrows
  std::pair<std::multimap<std::string, CGraphCurve>::iterator, std::multimap<std::string, CGraphCurve>::iterator> rangeCurveIt;
  std::multimap<std::string, CGraphCurve>::iterator curveIt;
  unsigned int i;

  for (i = 0; i < viewerNodes.size(); i++)
    {
      rangeCurveIt = nodeCurveMap.equal_range(viewerNodes[i]);
      std::map<std::string, CGraphNode>::iterator nodeIt = nodeMap.find(viewerNodes[i]); // find all edges belonging to a node

      if (nodeIt != nodeMap.end())
        {
          curveIt = rangeCurveIt.first;

          while (curveIt != rangeCurveIt.second)
            {
              this->adaptCurveForRectangles(curveIt, (*nodeIt).second.getBoundingBox());
              curveIt++;
            }
        }
    }

  this->drawGraph(); // this function will draw the bounding box for each node
}

void CQGLNetworkPainter::paintGL ( )

protected

Definition at line 549 of file CQGLNetworkPainter.cpp.

References draw().

{
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear The Screen And The Depth Buffer
  draw();
  glFlush();
}

void CQGLNetworkPainter::pauseAnimation

(

)

Definition at line 3190 of file CQGLNetworkPainter.cpp.

References regularTimer.

Referenced by CQLayoutMainWindow::pauseAnimation().

{
  regularTimer->stop();
}

void CQGLNetworkPainter::printAvailableFonts ( )

private

Definition at line 3056 of file CQGLNetworkPainter.cpp.

{
  QFontDatabase fdb;
  QStringList families = fdb.families();

  for (QStringList::Iterator f = families.begin(); f != families.end(); ++f)
    {
      QString family = *f;
      QStringList styles = fdb.styles(family);

      for (QStringList::Iterator s = styles.begin(); s != styles.end(); ++s)
        {
          QString style = *s;
          QString dstyle = "\t" + style + " (";
          QList<int> smoothies = fdb.smoothSizes(family, style);

          for (QList<int>::iterator points = smoothies.begin();
               points != smoothies.end(); ++points)
            {
              dstyle += QString::number(*points) + " ";
            }

          dstyle = dstyle.left(dstyle.length() - 1) + ")";
        }
    }
}

void CQGLNetworkPainter::printNodeInfoForKey ( std::string  key )

protected

Definition at line 3032 of file CQGLNetworkPainter.cpp.

{
  //std::map<std::string, CGraphNode>::iterator itNodeObj = nodeMap.find(key);
}

void CQGLNetworkPainter::printNodeMap ( )

private

Definition at line 3021 of file CQGLNetworkPainter.cpp.

References nodeMap.

{
  std::map<std::string, CGraphNode>::iterator nodeIt;
  nodeIt = nodeMap.begin();

  while (nodeIt != nodeMap.end())
    {
      nodeIt++;
    }
}

void CQGLNetworkPainter::removeMetaboliteForAnimation ( std::string  key )

private

void CQGLNetworkPainter::rescaleDataSets

(

CVisParameters::SCALING_MODE

scaleMode

)

Definition at line 1968 of file CQGLNetworkPainter.cpp.

References C_FLOAT64, CVisParameters::COLOR_MODE, CVisParameters::EPSILON, CQLayoutMainWindow::getMappingMode(), CSimSummaryInfo::getMaxForSpecies(), CQLayoutMainWindow::getMaxNodeSize(), CSimSummaryInfo::getMaxOverallConcentration(), CSimSummaryInfo::getMinForSpecies(), CQLayoutMainWindow::getMinNodeSize(), CSimSummaryInfo::getMinOverallConcentration(), CDataEntity::getOrigValueForSpecies(), CDataEntity::getValueForSpecies(), CVisParameters::INDIVIDUAL_SCALING, mDataSets, pParentLayoutWindow, pSummaryInfo, CDataEntity::putValueForSpecies(), setOfConstantMetabolites, and viewerNodes.

Referenced by CQLayoutMainWindow::setGlobalScaling(), and CQLayoutMainWindow::setIndividualScaling().

{
  unsigned int s; // step number
  C_FLOAT64 val, val_new;
  setOfConstantMetabolites.clear();

  for (s = 0; s < mDataSets.size(); s++)
    {
      CDataEntity& dataSet = mDataSets[s];
      unsigned int i;
      // try to get VisParameters from parent (CQLayoutMainWindow)
      C_FLOAT64 minNodeSize = 10;
      C_FLOAT64 maxNodeSize = 100;

      if (pParentLayoutWindow != NULL)
        {
          if (pParentLayoutWindow->getMappingMode() == CVisParameters::COLOR_MODE)
            {
              minNodeSize = 0.0;
              maxNodeSize = 1.0; // 456 color values from black to red to yellow
            }
          else
            {
              minNodeSize = pParentLayoutWindow->getMinNodeSize();
              maxNodeSize = pParentLayoutWindow->getMaxNodeSize();
            }
        }

      for (i = 0; i < viewerNodes.size(); i++) // iterate over string values (node keys)
        {
          // get old value
          val = dataSet.getValueForSpecies(viewerNodes[i]);

          if ((scaleMode == CVisParameters::INDIVIDUAL_SCALING) &&
              (pParentLayoutWindow != NULL))
            {
              // global mode -> individual mode
              // first get to original value
              C_FLOAT64 orig_value = dataSet.getOrigValueForSpecies(viewerNodes[i]);

              // recalculation of original value
              if ((pSummaryInfo->getMaxForSpecies(viewerNodes[i]) - pSummaryInfo->getMinForSpecies(viewerNodes[i])) > CVisParameters::EPSILON)
                {
                  // now rescale
                  val_new = ((orig_value - pSummaryInfo->getMinForSpecies(viewerNodes[i])) *
                             (maxNodeSize - minNodeSize) /
                             (pSummaryInfo->getMaxForSpecies(viewerNodes[i]) - pSummaryInfo->getMinForSpecies(viewerNodes[i])))
                            + minNodeSize;
                }
              else
                {
                  val_new = (maxNodeSize + minNodeSize) / 2.0;

                  if (s == 0) // only insert once into set
                    setOfConstantMetabolites.insert(viewerNodes[i]);
                }
            }
          else
            {
              // individual mode -> global mode
              C_FLOAT64 orig_value = dataSet.getOrigValueForSpecies(viewerNodes[i]);

              // first calculate original value
              if ((pSummaryInfo->getMaxOverallConcentration() - pSummaryInfo->getMinOverallConcentration()) > CVisParameters::EPSILON)
                {
                  // now rescale
                  val_new = ((orig_value - pSummaryInfo->getMinOverallConcentration()) *
                             (maxNodeSize - minNodeSize) /
                             (pSummaryInfo->getMaxOverallConcentration() - pSummaryInfo->getMinOverallConcentration()))
                            + minNodeSize;
                }
              else
                val_new = (maxNodeSize + minNodeSize) / 2.0;
            }

          dataSet.putValueForSpecies(viewerNodes[i], val_new);
        }
    }
}

void CQGLNetworkPainter::rescaleDataSetsWithNewMinMax	(	C_FLOAT64	oldMin,
		C_FLOAT64	oldMax,
		C_FLOAT64	newMin,
		C_FLOAT64	newMax,
		CVisParameters::SCALING_MODE	scaleMode
	)

Definition at line 1825 of file CQGLNetworkPainter.cpp.

References C_FLOAT64, CVisParameters::EPSILON, CSimSummaryInfo::getMaxForSpecies(), CSimSummaryInfo::getMaxOverallConcentration(), CSimSummaryInfo::getMinForSpecies(), CSimSummaryInfo::getMinOverallConcentration(), CDataEntity::getOrigValueForSpecies(), CDataEntity::getValueForSpecies(), CVisParameters::INDIVIDUAL_SCALING, mDataSets, pParentLayoutWindow, pSummaryInfo, CDataEntity::putValueForSpecies(), setOfConstantMetabolites, and viewerNodes.

Referenced by CQLayoutMainWindow::setColorMode(), CQLayoutMainWindow::setMaxValue(), CQLayoutMainWindow::setMinAndMaxValue(), CQLayoutMainWindow::setMinValue(), CQLayoutMainWindow::setSizeMode(), and zoom().

{
  unsigned int s; // step number
  C_FLOAT64 val, val_new;
  setOfConstantMetabolites.clear();

  for (s = 0; s < mDataSets.size(); s++) // for all steps
    {
      CDataEntity& dataSet = mDataSets[s];
      unsigned int i;

      for (i = 0; i < viewerNodes.size(); i++) // iterate over string values (node keys)
        {
          // get old value
          val = dataSet.getValueForSpecies(viewerNodes[i]);
          C_FLOAT64 a = 0.0, b = 1.0;

          if (pParentLayoutWindow != NULL)
            {
              if (scaleMode == CVisParameters::INDIVIDUAL_SCALING)
                {
                  a = pSummaryInfo->getMinForSpecies(viewerNodes[i]);
                  b = pSummaryInfo->getMaxForSpecies(viewerNodes[i]);
                }
              else // scaleMode == CVisParameters::GLOBAL_SCALING
                {
                  a = pSummaryInfo->getMinOverallConcentration();
                  b = pSummaryInfo->getMaxOverallConcentration();
                }
            }

          C_FLOAT64 val_orig;

          if ((b - a) > CVisParameters::EPSILON)
            {
              val_orig = dataSet.getOrigValueForSpecies(viewerNodes[i]); // get original value
              // now scale value
              val_new = newMin + ((val_orig - a) / (b - a) * (newMax - newMin));
            }
          else
            {
              // no scaling if differences are too small, just set mid value
              val_new = (newMax + newMin) / 2.0;

              if (s == 0) // only insert once into set
                setOfConstantMetabolites.insert(viewerNodes[i]);
            }

          dataSet.putValueForSpecies(viewerNodes[i], val_new);
        }
    }

  // if there is no time course data, we set all values to 0.0
  if (mDataSets.size() == 0)
    {
      CDataEntity dataSet;
      unsigned int i;

      for (i = 0; i < viewerNodes.size(); i++) // iterate over string values (node keys)
        {
          dataSet.putValueForSpecies(viewerNodes[i], 0.0);
        }

      mDataSets.push_back(dataSet);
    }
}

void CQGLNetworkPainter::rescaleNode	(	std::string	key,
		C_FLOAT64	newMin,
		C_FLOAT64	newMax,
		CVisParameters::SCALING_MODE	scaleMode
	)

Definition at line 1892 of file CQGLNetworkPainter.cpp.

References C_FLOAT64, CVisParameters::EPSILON, CSimSummaryInfo::getMaxForSpecies(), CSimSummaryInfo::getMaxOverallConcentration(), CSimSummaryInfo::getMinForSpecies(), CSimSummaryInfo::getMinOverallConcentration(), CDataEntity::getOrigValueForSpecies(), CDataEntity::getValueForSpecies(), CVisParameters::INDIVIDUAL_SCALING, mDataSets, pParentLayoutWindow, pSummaryInfo, CDataEntity::putValueForSpecies(), and setOfConstantMetabolites.

Referenced by setItemAnimated().

{
  // this is called if a species which has been disabled in the animation is reenabled
  unsigned int s; // step number
  C_FLOAT64 val, val_new;
  setOfConstantMetabolites.clear();

  for (s = 0; s < mDataSets.size(); s++) // for all steps
    {
      CDataEntity& dataSet = mDataSets[s];
      // get old value
      val = dataSet.getValueForSpecies(key);
      C_FLOAT64 a = 0.0, b = 1.0;

      if (pParentLayoutWindow != NULL)
        {
          if (scaleMode == CVisParameters::INDIVIDUAL_SCALING)
            {
              a = pSummaryInfo->getMinForSpecies(key);
              b = pSummaryInfo->getMaxForSpecies(key);
            }
          else // scaleMode == CVisParameters::GLOBAL_SCALING
            {
              a = pSummaryInfo->getMinOverallConcentration();
              b = pSummaryInfo->getMaxOverallConcentration();
            }
        }

      C_FLOAT64 val_orig;

      if ((b - a) > CVisParameters::EPSILON)
        {
          val_orig = dataSet.getOrigValueForSpecies(key); // get original value
          // now scale value
          val_new = newMin + ((val_orig - a) / (b - a) * (newMax - newMin));
        }
      else
        {
          // no scaling if differences are too small, just set mid value
          val_new = (newMax + newMin) / 2.0;

          if (s == 0) // only insert once into set
            setOfConstantMetabolites.insert(key);
        }

      dataSet.putValueForSpecies(key, val_new);
    }
}

void CQGLNetworkPainter::resetView

(

)

Definition at line 3152 of file CQGLNetworkPainter.cpp.

References getGraphMin(), setCurrentPosition(), and setZoomFactor().

Referenced by CQGLViewport::resetView().

{
  this->setZoomFactor(1.0);
  this->setCurrentPosition(this->getGraphMin().getX(), this->getGraphMin().getY());
}

void CQGLNetworkPainter::resizeGL ( int  w, int  h  )

protected

Definition at line 535 of file CQGLNetworkPainter.cpp.

References mCurrentPositionX, mCurrentPositionY, and mCurrentZoom.

Referenced by export_bitmap(), and update().

{
  // setup viewport, projection etc.:
  glViewport(0, 0, (GLint)w, (GLint)h);

  glMatrixMode(GL_PROJECTION);    // Select The Projection Matrix
  glLoadIdentity();             // Reset The Projection Matrix
  gluOrtho2D((GLdouble)mCurrentPositionX,
             (GLdouble)(mCurrentPositionX + w / mCurrentZoom),
             (GLdouble)(mCurrentPositionY + h / mCurrentZoom),
             (GLdouble)mCurrentPositionY); // y: 0.0 is bottom left instead of top left as in SBML
  glMatrixMode(GL_MODELVIEW);  // Select The Modelview Matrix
}

RGTextureSpec * CQGLNetworkPainter::RG_createTextureForText ( const std::string &  text, const std::string &  fontName, unsigned int  fontSize  )

private

Definition at line 1670 of file CQGLNetworkPainter.cpp.

References RGTextureSpec::textHeight, RGTextureSpec::textureData, RGTextureSpec::textureHeight, RGTextureSpec::textureWidth, RGTextureSpec::textWidth, and RGTextureSpec::textYOffset.

Referenced by createTextureForAllLabels(), and getTextureForText().

{
  QFont font(QString(fontName.c_str()), fontSize);
  QFontMetrics fontMetrics = QFontMetrics(font);

  QRect rect = fontMetrics.boundingRect(QString(text.c_str()));
  int width = rect.width();
  int height = rect.height();
  int exponent = static_cast<int>(ceil(log2(width + 2.0)));

  if (exponent < 6)
    {
      exponent = 6;
    }

  width = static_cast<int>(pow(2.0, exponent + 1));
  exponent = static_cast<int>(ceil(log2(height + 2.0)));

  if (exponent < 6)
    {
      exponent = 6;
    }

  height = static_cast<int>(pow(2.0, exponent + 1));

  QPixmap pixmap(width, height);
  pixmap.fill(QColor(255, 255, 255));
  QGraphicsScene scene(0.0, 0.0, width, height);
  QGraphicsTextItem* pTextItem = scene.addText(QString(text.c_str()), font);
  pTextItem->setDefaultTextColor(QColor(0, 0, 0));
  // also move one to the right and one down to generate one column
  // and one row of transparent pixels
  pTextItem->moveBy(1.0, 1.0);
  QPainter painter(&pixmap);
  scene.render(&painter);

  RGTextureSpec* texture = new RGTextureSpec();
  texture->textureData = new GLubyte[height * width];
  texture->textureWidth = width;
  texture->textureHeight = height;
  texture->textWidth = rect.width();
  texture->textHeight = rect.height();
  QImage image = pixmap.toImage(); // UR
  // write the texture to a file to check if they were created correctly
  //bool tmpRes=image.save(text+".png","PNG");
  //assert(tmpRes == true);
  int i, j;
  int firstWhitePixel = height;
  char pixelValue;
  QRgb pixel;

  for (i = 0; i < height; ++i)
    {
      for (j = 0; j < width; ++j)
        {
          pixel = image.pixel(j, i);
          pixelValue = static_cast<unsigned char>(255 - (qRed(pixel) + qGreen(pixel) + qBlue(pixel)) / 3);
          texture->textureData[i * width + j] = pixelValue;

          if (pixelValue != 0)
            {
              if (firstWhitePixel == height)
                {
                  firstWhitePixel = i;
                }
            }
        }
    }

  texture->textYOffset = firstWhitePixel;
  // write the actual texture to a file
  //texture->save(text+".tga");
  return texture;
}

void CQGLNetworkPainter::RG_drawStringAt ( std::string  s, C_INT32  x, C_INT32  y, C_INT32  w, C_INT32  h  )

private

Definition at line 1556 of file CQGLNetworkPainter.cpp.

References getTextureForText(), mFontname, mTextColor, RGTextureSpec::textHeight, RGTextureSpec::textureData, RGTextureSpec::textureHeight, textureNames, RGTextureSpec::textureWidth, RGTextureSpec::textWidth, and RGTextureSpec::textYOffset.

Referenced by drawColorLegend(), and drawGraph().

{
  RGTextureSpec* texSpec = getTextureForText(s, mFontname, h);

  if (texSpec == NULL)
    {
      return;
    }

  glPushMatrix();
  glColor4fv(mTextColor);
  glEnable(GL_TEXTURE_2D);
  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  glBindTexture(GL_TEXTURE_2D, textureNames[0]);
  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  glTexImage2D(GL_TEXTURE_2D, 0, GL_INTENSITY8, static_cast<int>(texSpec->textureWidth), static_cast<int>(texSpec->textureHeight), 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, texSpec->textureData);
  glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
  glTranslated(x, y, 0.5);

  double xOffset = (w - texSpec->textWidth + 2) / 2.0;
  double yOffset = (h - texSpec->textHeight + texSpec->textYOffset + 2) / 2.0;
  xOffset = (xOffset < 0.0) ? 0.0 : xOffset;
  yOffset = (yOffset < 0.0) ? 0.0 : yOffset;
  double textureXRatio = ((texSpec->textWidth + 2) / texSpec->textureWidth) / ((w - xOffset) / w) * 1.02;
  double textureYRatio = ((texSpec->textHeight + 2) / texSpec->textureHeight) / ((h - 2 * yOffset) / h);

  glBegin(GL_POLYGON);
  glTexCoord2f(-xOffset / texSpec->textureWidth, -yOffset / texSpec->textureHeight);
  glVertex3f(0.0, 0.0, 0.0);

  glTexCoord2f(textureXRatio, -yOffset / texSpec->textureHeight);
  glVertex3f(w, 0.0, 0.0);

  glTexCoord2f(textureXRatio, textureYRatio);
  glVertex3f(w, h, 0.0);

  glTexCoord2f(-xOffset / texSpec->textureWidth, textureYRatio);
  glVertex3f(0.0, h, 0.0);
  glEnd();

  glDisable(GL_TEXTURE_2D);
  glPopMatrix();
}

int CQGLNetworkPainter::round2powN ( double  d )

private

Definition at line 1796 of file CQGLNetworkPainter.cpp.

Referenced by drawStringAt().

{
  int n = (int)(ceil(d));
  int p = 1;
  int maxP = 12; // max size of images 2*12

  while ((p <= maxP) && (n > pow(2.0, p)))
    p++;

  return (int)pow(2.0, p);
}

void CQGLNetworkPainter::runAnimation

(

)

Definition at line 2214 of file CQGLNetworkPainter.cpp.

References C_INT16, CIRCLE, createDataSets(), CQLayoutMainWindow::getStepsPerSecond(), mDataSets, mLabelShape, pParentLayoutWindow, regularTimer, and CQLayoutMainWindow::setAnimationRunning().

Referenced by CQLayoutMainWindow::startAnimation().

{
  this->mLabelShape = CIRCLE;

  if (mDataSets.empty())
    {
      this->createDataSets(); // load data if this was not done before
    }

  // try to get VisParameters from parent (CQLayoutMainWindow)

  C_INT16 stepsPerSecond = 10;

  if (pParentLayoutWindow != NULL)
    {
      pParentLayoutWindow->setAnimationRunning(true);
      stepsPerSecond = pParentLayoutWindow->getStepsPerSecond();
    }

  regularTimer->setSingleShot(false);
  regularTimer->start((int)(1000 / stepsPerSecond)); // emit signal in chosen frame rate
}

void CQGLNetworkPainter::setConstantNodeSize	(	std::string	key,
		C_FLOAT64	val
	)

Definition at line 1952 of file CQGLNetworkPainter.cpp.

References mDataSets, CDataEntity::putValueForSpecies(), and setOfConstantMetabolites.

{
  unsigned int s; // step number
  setOfConstantMetabolites.clear();

  for (s = 0; s < mDataSets.size(); s++) // for all steps
    {
      CDataEntity& dataSet = mDataSets[s];
      // get old value
      dataSet.putValueForSpecies(key, val);
    }
}

void CQGLNetworkPainter::setConstantNodeSizeForAllSteps	(	std::string	key,
		C_FLOAT64	midValue
	)

Definition at line 1941 of file CQGLNetworkPainter.cpp.

References mDataSets, and CDataEntity::putValueForSpecies().

Referenced by setItemAnimated().

{
  unsigned int s; // step number

  for (s = 0; s < mDataSets.size(); s++) // for all steps
    {
      CDataEntity& dataSet = mDataSets[s];
      dataSet.putValueForSpecies(key, val);
    }
}

void CQGLNetworkPainter::setCurrentPosition	(	C_FLOAT64	x,
		C_FLOAT64	y
	)

Definition at line 3101 of file CQGLNetworkPainter.cpp.

References mCurrentPositionX, mCurrentPositionY, and update().

Referenced by fitToScreen(), and resetView().

{
  if (this->mCurrentPositionX != x || this->mCurrentPositionY != y)
    {
      this->mCurrentPositionX = x;
      this->mCurrentPositionY = y;
      this->update();
    }
}

void CQGLNetworkPainter::setCurrentPositionX

(

C_FLOAT64

x

)

Definition at line 3124 of file CQGLNetworkPainter.cpp.

References mCurrentPositionX, and update().

Referenced by CQGLViewport::slotHValueChanged().

{
  if (this->mCurrentPositionX != x)
    {
      this->mCurrentPositionX = x;
      this->update();
    }
}

void CQGLNetworkPainter::setCurrentPositionY

(

C_FLOAT64

y

)

Definition at line 3133 of file CQGLNetworkPainter.cpp.

References mCurrentPositionY, and update().

Referenced by CQGLViewport::slotVValueChanged().

{
  if (this->mCurrentPositionY != y)
    {
      this->mCurrentPositionY = y;
      this->update();
    }
}

void CQGLNetworkPainter::setFontSize ( )

privateslot

Definition at line 2708 of file CQGLNetworkPainter.cpp.

Referenced by createActions().

{
  FontChooser *fCh = new FontChooser(this);
  fCh->exec();
}

void CQGLNetworkPainter::setFontSizeForLabels

(

unsigned int

fs

)

Definition at line 2823 of file CQGLNetworkPainter.cpp.

References createTextureForAllLabels(), drawGraph(), mFontsize, mFontsizeDouble, update(), and viewerLabels.

Referenced by FontChooser::changeFontSize(), and CQLayoutMainWindow::setFontSizeForLabels().

{
  this->mFontsizeDouble = fs;
  this->mFontsize = (int)this->mFontsizeDouble;

  unsigned int i;

  for (i = 0; i < viewerLabels.size(); i++)
    {
      this->viewerLabels[i].adaptToHeight(fs);
    }

  createTextureForAllLabels();
  this->drawGraph();
  this->update();
}

void CQGLNetworkPainter::setGraphSize	(	const CLPoint &	min,
		const CLPoint &	max
	)

Definition at line 569 of file CQGLNetworkPainter.cpp.

References CLPoint::getX(), CLPoint::getY(), mgraphMax, mgraphMin, CLPoint::setX(), and CLPoint::setY().

Referenced by createGraph().

{
  mgraphMin.setX(min.getX());
  mgraphMin.setY(min.getY());
  mgraphMax.setX(max.getX());
  mgraphMax.setY(max.getY());
}

void CQGLNetworkPainter::setItemAnimated	(	std::string	key,
		bool	animatedP
	)

Definition at line 1808 of file CQGLNetworkPainter.cpp.

References C_FLOAT64, CQLayoutMainWindow::getCurrentStep(), CQLayoutMainWindow::getMaxNodeSize(), CQLayoutMainWindow::getMinNodeSize(), CQLayoutMainWindow::getScalingMode(), pParentLayoutWindow, rescaleNode(), setConstantNodeSizeForAllSteps(), setOfDisabledMetabolites, and showStep().

Referenced by CQLayoutMainWindow::addItemInAnimation(), and CQLayoutMainWindow::removeItemInAnimation().

{
  if (!animatedP)
    {
      setOfDisabledMetabolites.insert(key);
      C_FLOAT64 midValue = (pParentLayoutWindow->getMinNodeSize() + pParentLayoutWindow->getMaxNodeSize()) / 2.0; // node size used here is set to mid between min and max node size (for reactants that are not animated)
      setConstantNodeSizeForAllSteps(key, midValue);
    }
  else
    {
      setOfDisabledMetabolites.erase(key);
      rescaleNode(key, pParentLayoutWindow->getMinNodeSize(), pParentLayoutWindow->getMaxNodeSize(), pParentLayoutWindow->getScalingMode());
    }

  this->showStep(pParentLayoutWindow->getCurrentStep());
}

void CQGLNetworkPainter::setNodeSize	(	std::string	key,
		C_FLOAT64	val
	)

Definition at line 2384 of file CQGLNetworkPainter.cpp.

References C_FLOAT64, CLLineSegment::getBase1(), CLLineSegment::getBase2(), CLLineSegment::getEnd(), CLCurve::getNumCurveSegments(), CLCurve::getSegmentAt(), CLLineSegment::getStart(), CLPoint::getX(), CLPoint::getY(), CGraphCurve::hasArrowP(), CLLineSegment::isBezier(), mCurrentZoom, nodeArrowMap, nodeCurveMap, nodeMap, CGraphCurve::setArrow(), and CLLineSegment::setEnd().

Referenced by showStep().

{
  // curves to nodes are changed, arrows are created newly
  nodeArrowMap.clear();
  std::map<std::string, CGraphNode>::iterator nodeIt;
  nodeIt = nodeMap.find(key);

  if (nodeIt != nodeMap.end())
    (*nodeIt).second.setSize(val);

  // now adaptCurves pointing to nodes
  std::pair<std::multimap<std::string, CGraphCurve>::iterator, std::multimap<std::string, CGraphCurve>::iterator> curveRangeIt;;
  curveRangeIt = nodeCurveMap.equal_range(key);
  std::multimap<std::string, CGraphCurve>::iterator curveIt;
  curveIt = curveRangeIt.first;

  while (curveIt != curveRangeIt.second)
    {
      CGraphCurve *pCurve = & (*curveIt).second;

      if (pCurve != NULL && pCurve->getNumCurveSegments() > 0)
        {
          CLLineSegment* pLastSeg = pCurve->getSegmentAt(pCurve->getNumCurveSegments() - 1); // get pointer to last segment

          // move end point of segment along the line from the circle center(=from) to the current end point of the last segment
          // so that it lies on the border of the circle
          CLPoint to;

          if (pLastSeg->isBezier())
            {
              to = pLastSeg->getBase2();
              CLPoint p = pLastSeg->getEnd();

              // check if the second base point and the endpoint are identical
              if (fabs(p.getX() - to.getX() + p.getY() - to.getY()) < 1e-8)
                {
                  // if yes, take the first basepoint
                  to = pLastSeg->getBase1();

                  // if they are still identical take the start point because
                  // it is a straight line
                  if (fabs(p.getX() - to.getX() + p.getY() - to.getY()) < 1e-8)
                    {
                      to = pLastSeg->getStart();
                    }
                }
            }
          else
            {
              to = pLastSeg->getStart();
            }

          CLPoint from = CLPoint((*nodeIt).second.getX() + ((*nodeIt).second.getWidth() / 2.0), (*nodeIt).second.getY() + ((*nodeIt).second.getHeight() / 2.0)); // center of bounding box and also of circle
          C_FLOAT64 distance = sqrt(((to.getX() - from.getX()) * (to.getX() - from.getX())) + ((to.getY() - from.getY()) * (to.getY() - from.getY())));

          C_FLOAT64 circleDist = ((*nodeIt).second.getSize() / 2.0) + 4.0; // near border
          C_FLOAT64 newX = from.getX() + ((to.getX() - from.getX()) / distance * circleDist);
          C_FLOAT64 newY = from.getY() + ((to.getY() - from.getY()) / distance * circleDist);

          pLastSeg->setEnd(CLPoint(newX, newY));
          // now insert new arrow in map
          CLPoint p = pLastSeg->getEnd();

          if (pCurve->hasArrowP())
            {
              CLLineSegment ls(to, pLastSeg->getEnd());
              CArrow *ar = new CArrow(ls, p.getX(), p.getY(), this->mCurrentZoom);
              nodeArrowMap.insert(std::pair<std::string, CArrow>
                                  (key, *ar));
              pCurve->setArrow(*ar);
              delete ar;
            }
        }

      curveIt++;
    }
}

void CQGLNetworkPainter::setNodeSizeWithoutChangingCurves	(	std::string	key,
		C_FLOAT64	val
	)

Definition at line 2374 of file CQGLNetworkPainter.cpp.

References nodeMap.

Referenced by showStep().

{
  std::map<std::string, CGraphNode>::iterator nodeIt;
  nodeIt = nodeMap.find(key);

  if (nodeIt != nodeMap.end())
    (*nodeIt).second.setSize(val);
}

void CQGLNetworkPainter::setScaleMode

(

CVisParameters::SCALING_MODE

scaleMode

)

Sets the scaling mode to either global or individual scaling.

Definition at line 3218 of file CQGLNetworkPainter.cpp.

References mScaleMode.

Referenced by CQLayoutMainWindow::setGlobalScaling(), and CQLayoutMainWindow::setIndividualScaling().

{
  this->mScaleMode = scaleMode;
}

void CQGLNetworkPainter::setZoomFactor

(

C_FLOAT64

zoom

)

Definition at line 3083 of file CQGLNetworkPainter.cpp.

References mCurrentZoom, and zoom().

Referenced by fitToScreen(), resetView(), and CQGLViewport::setZoomFactor().

{
  if (zoom != this->mCurrentZoom)
    {
      this->mCurrentZoom = zoom;

      if (this->isVisible())
        {
          this->updateGL();
        }
    }
}

void CQGLNetworkPainter::showStep

(

size_t

i

)

Definition at line 2276 of file CQGLNetworkPainter.cpp.

References CIRCLE, CVisParameters::COLOR_MODE, CVisParameters::DEFAULT_NODE_SIZE, drawGraph(), CVisParameters::EPSILON, CQLayoutMainWindow::getMappingMode(), CSimSummaryInfo::getMaxForSpecies(), CQLayoutMainWindow::getMaxNodeSize(), CSimSummaryInfo::getMaxOverallConcentration(), CSimSummaryInfo::getMinForSpecies(), CQLayoutMainWindow::getMinNodeSize(), CSimSummaryInfo::getMinOverallConcentration(), CDataEntity::getOrigValueForSpecies(), CVisParameters::INDIVIDUAL_SCALING, max, mDataSets, min, mLabelShape, mScaleMode, nodeMap, pParentLayoutWindow, pSummaryInfo, setNodeSize(), setNodeSizeWithoutChangingCurves(), setOfConstantMetabolites, setOfDisabledMetabolites, stepShown, and viewerNodes.

Referenced by CQLayoutMainWindow::backwardAnimation(), export_bitmap(), setItemAnimated(), and CQLayoutMainWindow::showStep().

{
  this->stepShown = stepNumber;

  if (this->mLabelShape != CIRCLE)
    this->mLabelShape = CIRCLE;

  if (stepNumber < mDataSets.size())
    {
      CDataEntity dataSet = mDataSets[stepNumber];
      unsigned int i;

      for (i = 0; i < viewerNodes.size(); i++)
        {
          if (pParentLayoutWindow != NULL)
            {
              double val = dataSet.getOrigValueForSpecies(viewerNodes[i]);
              // do the scaling here instead of elsewhere
              double a, b;

              if (mScaleMode == CVisParameters::INDIVIDUAL_SCALING)
                {
                  a = pSummaryInfo->getMinForSpecies(viewerNodes[i]);
                  b = pSummaryInfo->getMaxForSpecies(viewerNodes[i]);
                }
              else // mScaleMode == CVisParameters::GLOBAL_SCALING
                {
                  a = pSummaryInfo->getMinOverallConcentration();
                  b = pSummaryInfo->getMaxOverallConcentration();
                }

              if ((b - a) > CVisParameters::EPSILON)
                {
                  val = (val - a) / (b - a);
                }
              else
                {
                  // no scaling if differences are too small, just set mid value
                  val = 0.5;
                  setOfConstantMetabolites.insert(viewerNodes[i]);
                }

              if (pParentLayoutWindow->getMappingMode() != CVisParameters::COLOR_MODE)
                {
                  // no color mode

                  if (val != -std::numeric_limits< C_FLOAT64 >::max())
                    {
                      if (isnan(val)) // test for NaN
                        {
                          std::map<std::string, CGraphNode>::iterator itNodeObj = nodeMap.find(viewerNodes[i]);

                          if (itNodeObj != nodeMap.end())
                            {
                            }

                          setNodeSize(viewerNodes[i], CVisParameters::DEFAULT_NODE_SIZE);
                        }
                      else
                        {
                          if (setOfDisabledMetabolites.find(viewerNodes[i]) == setOfDisabledMetabolites.end())
                            {
                              double min = pParentLayoutWindow->getMinNodeSize();
                              double max = pParentLayoutWindow->getMaxNodeSize();
                              setNodeSize(viewerNodes[i], min + val * (max - min));
                            }
                          else
                            {
                              setNodeSize(viewerNodes[i], CVisParameters::DEFAULT_NODE_SIZE);
                            }
                        }
                    }
                }
              else // COLOR_MODE
                {
                  // TODO the call to setNodeSize should not be necessary since the nodes don't change in size during a color coded
                  // TODO animation, so the arrow heads don't have to be recalculated
                  setNodeSize(viewerNodes[i], CVisParameters::DEFAULT_NODE_SIZE);

                  if (val != -std::numeric_limits< C_FLOAT64 >::max())
                    {
                      if (isnan(val)) // test for NaN
                        {
                          setNodeSize(viewerNodes[i], CVisParameters::DEFAULT_NODE_SIZE);
                        }
                      else
                        {
                          setNodeSizeWithoutChangingCurves(viewerNodes[i], val);
                        }
                    }
                }
            }
        }
    }

  this->drawGraph();
}

void CQGLNetworkPainter::signalZoomIn ( )

signal

Referenced by zoomIn().

void CQGLNetworkPainter::signalZoomOut ( )

signal

Referenced by zoomOut().

void CQGLNetworkPainter::stepChanged ( int  )

signal

Referenced by initializeGraphPainter(), and triggerAnimationStep().

void CQGLNetworkPainter::testOpenGL ( )

protected

Definition at line 2855 of file CQGLNetworkPainter.cpp.

{
  glLoadIdentity();
  glTranslatef(10.0f, 10.0f, -1.0f);
  glBegin(GL_TRIANGLES);          // Drawing Using Triangles
  glColor3f(0.0f, 0.0f, 1.0f);
  glVertex3f(0.0f, 10.0f, 0.0f);    // Top
  glVertex3f(-10.0f, -10.0f, 0.0f);    // Bottom Left
  glVertex3f(10.0f, -10.0f, 0.0f);    // Bottom Right
  glEnd();

  glTranslatef(3.0f, 0.0f, 0.0f);
  glBegin(GL_QUADS);          // Draw A Quad
  glColor3f(1.0f, 0.0f, 0.0f);
  glVertex3f(-1.0f, 1.0f, 0.0f);    // Top Left
  glVertex3f(1.0f, 1.0f, 0.0f);    // Top Right
  glVertex3f(1.0f, -1.0f, 0.0f);    // Bottom Right
  glVertex3f(-1.0f, -1.0f, 0.0f);    // Bottom Left
  glEnd();       // Done Drawing The Quad

  glTranslatef(3.5f, 0.0f, 0.0f);
  glBegin(GL_POLYGON);     // Ein Polygon (in diesem Falle ein Achteck.)
  // jede Ecke bekommt eine andere Farbe
  glColor3f(1.0f, 0.0f, 0.0f); // rot
  glVertex3f(-0.5f, 1.5f, 0.0f); // obere Ecke links
  glVertex3f(0.5f, 1.5f, 0.0f); // obere Ecke rechts

  glColor3f(0.0f, 0.0f, 1.0f); // blau
  glVertex3f(1.5f, 0.5f, 0.0f); // rechte Ecke oben
  glVertex3f(1.5f, -0.5f, 0.0f); // rechte Ecke unten

  glColor3f(0.0f, 1.0f, 0.0f); // gruen
  glVertex3f(0.5f, -1.5f, 0.0f); // untere Ecke rechts
  glVertex3f(-0.5f, -1.5f, 0.0f); // untere Ecke links

  glColor3f(1.0f, 1.0f, 0.0f); // gelb
  glVertex3f(-1.5f, -0.5f, 0.0f); // linke Ecke unten
  glVertex3f(-1.5f, 0.5f, 0.0f); // linke Ecke oben
  glEnd(); // Zeichenaktion beenden
}

void CQGLNetworkPainter::triggerAnimationStep ( )

slot

Definition at line 2237 of file CQGLNetworkPainter.cpp.

References endOfAnimationReached(), CQLayoutMainWindow::getAnimationRunning(), getNumberOfSteps(), pParentLayoutWindow, regularTimer, stepChanged(), and stepShown.

Referenced by initializeGraphPainter().

{
  size_t numberOfSteps = 100;
  bool animationRunning = true;

  if (pParentLayoutWindow != NULL)
    {
      //check whether animation is running
      animationRunning = pParentLayoutWindow->getAnimationRunning();
    }

  numberOfSteps = getNumberOfSteps();

  if ((stepShown <= numberOfSteps) &&
      (animationRunning))
    {
      // set value in slider
      emit stepChanged((int) stepShown);
      this->stepShown++;
    }
  else
    {
      regularTimer->stop();
      emit endOfAnimationReached();
    }
}

void CQGLNetworkPainter::update

(

)

Definition at line 3111 of file CQGLNetworkPainter.cpp.

References mIsInitialized, and resizeGL().

Referenced by