GLViewer_Tools.h

Go to the documentation of this file.

// Copyright (C) 2007-2023  CEA, EDF, OPEN CASCADE
//
// Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
 
//  Author : OPEN CASCADE
// File:      GLViewer_Tools.h
// Created:   April, 2005
//
#ifndef GLVIEWER_TOOLS_H
#define GLVIEWER_TOOLS_H
 
#ifdef WIN32
#include "windows.h"
#endif
 
#include "GLViewer.h"
 
class GLVIEWER_API GLViewer_Tools
{
public:
        //GLViewer_Tools();
        //virtual ~GLViewer_Tools();
  //static 
 
};
 
enum FieldDim
{
  FD_X = 0, /*along x axis*/
  FD_Y      /*along y axis*/
};
 
class GLViewer_LineList  
{
public:
  GLViewer_LineList( int  );
  virtual ~GLViewer_LineList();
 
  int         count() const { return mySegmentNumber; }
  int         size() const { return myRealSize; }
  
  bool        addSegment( double coord1, double coord2 );
  bool        removeSegment( int index );
  bool        removeSegment( double coord1, double coord2 );
 
  bool        readSegment( int index, double& coord1, double& coord2 );
 
  int         contains( double thePoint ) const;
 
  void        setMainCoord( double theVal ) { myMainCoord = theVal; }
  double      mainCoord() const { return myMainCoord; }
 
  void        clear();
  void        print();
 
  void        show( FieldDim );
  
  GLViewer_LineList& operator = ( GLViewer_LineList );
 
private:
  double*     myArray;
  int         myRealSize;
  int         mySegmentNumber;
 
  double      myMainCoord;
};
 
struct GraphNode
{
  int       myCount;
  FieldDim  myDim;
  int       myLineIndex;
  int       mySegmentindex;
  int       prevNodeIndex; //feedback for searching for solution
};
 
struct SearchPoint
{
  int       myXLineIndex;
  int       myXSegmentIndex;
  int       myYLineIndex;
  int       myYSegmentIndex;
  int       mySolveIndex;
};
 
class GLViewer_LineField
{
public:
  enum  FieldPoint
  {
    FP_Start = 0,
    FP_End = 1
  };
 
  enum IterationStatus
  {
    IS_ERROR = 0,
    IS_LOOP,
    IS_NOT_SOLVED,
    IS_SOLVED
  };
 
  enum EndStatus
  {
    ES_ERROR = 0,
    ES_LOOP,
    ES_SOLVED
  };
 
  GLViewer_LineField();
  GLViewer_LineField( const int theMAXSize, const int xn, const int yn );
  virtual ~GLViewer_LineField();
 
 
  void                addLine( FieldDim, GLViewer_LineList* );
  void                addLine( FieldDim theDim, double theMC, double theBegin, double theEnd );
  
 
  int                 insertLine( FieldDim theDim, GLViewer_LineList*, int thePosition );
  int                 insertLine( FieldDim theDim, double theMC, double theBegin, double theEnd, int thePosition );
 
  static FieldDim     invertDim( FieldDim );
 
  GLViewer_LineList*  getLine( int index, FieldDim );
 
  void                setBorders( double X1, double X2, double Y1, double Y2 );
  void                addRectangle( double top, double right, double bottom, double left );
 
  int*                intersectIndexes( FieldDim theDim, int theIndex, const GLViewer_LineList* theLL , int& theSize );
 
  void                print();
 
  void                show();  
 
  int                 getDimSize( FieldDim );
  int                 segmentNumber();
 
  bool                setPoint( FieldPoint, double x, double y );
 
 
  void                optimize();
 
  void                initialize();
  EndStatus           startAlgorithm();
 
  double*             solution( int& size );
 
protected:
  void                iteration();
  IterationStatus     checkComplete();  
 
  int*                findByCount( int& theParam );
  int                 findBySegment( FieldDim, int coord1, int coord2, bool inCurArray = true );
 
  GraphNode*          getCurArray();
  GraphNode*          getSecArray();
 
  int                 maxSegmentNum();
 
  GLViewer_LineList** getLLArray( FieldDim );
 
private:
  GLViewer_LineList**    myXLineArray,
                   **    myYLineArray;
 
  int           myXSize,
                myYSize;
 
  GraphNode*    myGraphArray1,
           *    myGraphArray2;
  int           myCurArrayIndex;
 
  SearchPoint   myStartPoint,
                myEndPoint;
  int           myCurCount;
};
 
#endif //GLVIEWER_TOOLS_H