g4tools  5.4.0
Classes | Public Member Functions | Protected Member Functions | Static Protected Member Functions | Protected Attributes | List of all members
tools::ccontour Class Referenceabstract
Inheritance diagram for tools::ccontour:
Inheritance graph
[legend]
Collaboration diagram for tools::ccontour:
Collaboration graph
[legend]

Public Member Functions

 ccontour ()
 
virtual ~ccontour ()
 
virtual void generate ()
 
void set_first_grid (int iCol, int iRow)
 
void set_secondary_grid (int iCol, int iRow)
 
void set_limits (double pLimits[4])
 
void set_planes (const std::vector< double > &vPlanes)
 
void set_field_fcn (double(*_pFieldFcn)(double, double, void *), void *)
 
size_t get_number_of_planes () const
 
const std::vector< double > & get_planes () const
 
double get_plane (unsigned int i) const
 
double get_xi (int i) const
 
double get_yi (int i) const
 
void get_limits (double pLimits[4])
 

Protected Member Functions

virtual void ExportLine (int iPlane, int x1, int y1, int x2, int y2)=0
 
 ccontour (const ccontour &)
 
virtual void InitMemory ()
 
virtual void CleanMemory ()
 
int GetColFir () const
 
int GetRowFir () const
 
int GetColSec () const
 
int GetRowSec () const
 
CFnStr * FnctData (int i, int j)
 
double Field (int x, int y)
 
void Cntr1 (int x1, int x2, int y1, int y2)
 
void Pass2 (int x1, int x2, int y1, int y2)
 

Static Protected Member Functions

static void _ASSERT_ (bool a_what, const char *a_where)
 
static void _ASSERTP_ (void *a_what, const char *a_where)
 

Protected Attributes

std::vector< double > m_vPlanes
 
double m_pLimits [4]
 
int m_iColFir
 
int m_iRowFir
 
int m_iColSec
 
int m_iRowSec
 
void * m_pFieldFcnData
 
double(* m_pFieldFcn )(double x, double y, void *)
 
double m_dDx
 
double m_dDy
 
CFnStr ** m_ppFnData
 

Detailed Description

Definition at line 54 of file ccontour.

Constructor & Destructor Documentation

◆ ccontour() [1/2]

tools::ccontour::ccontour ( )
inline

Definition at line 225 of file ccontour.

226 {
227 #ifdef TOOLS_MEM
228  mem::increment(s_class().c_str());
229 #endif
230  m_iColFir=m_iRowFir=32;
231  m_iColSec=m_iRowSec=256;
232  m_dDx=m_dDy=0;
233  m_pFieldFcnData = NULL;
234  m_pFieldFcn=NULL;
235  m_pLimits[0]=m_pLimits[2]=0;
236  m_pLimits[1]=m_pLimits[3]=5.;
237  m_ppFnData=NULL;
238 
239  // temporary stuff
240  m_pFieldFcn=ContourTestFunction;
241  m_vPlanes.resize(20);
242  for (unsigned int i=0;i<m_vPlanes.size();i++)
243  {
244  m_vPlanes[i]=(i-m_vPlanes.size()/2.0)*0.1;
245  }
246 }

◆ ~ccontour()

virtual tools::ccontour::~ccontour ( )
inlinevirtual

Definition at line 68 of file ccontour.

68  {
69  CleanMemory();
70 #ifdef TOOLS_MEM
71  mem::decrement(s_class().c_str());
72 #endif
73  }

◆ ccontour() [2/2]

tools::ccontour::ccontour ( const ccontour &  )
inlineprotected

Definition at line 75 of file ccontour.

75 {}

Member Function Documentation

◆ _ASSERT_()

static void tools::ccontour::_ASSERT_ ( bool  a_what,
const char *  a_where 
)
inlinestaticprotected

Definition at line 197 of file ccontour.

197  {
198  if(!a_what) {
199  ::printf("debug : Contour : assert failure in %s\n",a_where);
200  ::exit(0);
201  }
202  }

◆ _ASSERTP_()

static void tools::ccontour::_ASSERTP_ ( void *  a_what,
const char *  a_where 
)
inlinestaticprotected

Definition at line 204 of file ccontour.

204  {
205  if(!a_what) {
206  ::printf("debug : Contour : assert failure in %s\n",a_where);
207  ::exit(0);
208  }
209  }

◆ CleanMemory()

void tools::ccontour::CleanMemory ( )
inlineprotectedvirtual

Reimplemented in tools::clist_contour.

Definition at line 262 of file ccontour.

263 {
264  if (m_ppFnData)
265  {
266  int i;
267  for (i=0;i<m_iColSec+1;i++)
268  {
269  if (m_ppFnData[i])
270  delete[] (m_ppFnData[i]);
271  }
272  delete[] m_ppFnData;
273  m_ppFnData=NULL;
274  }
275 }

◆ Cntr1()

void tools::ccontour::Cntr1 ( int  x1,
int  x2,
int  y1,
int  y2 
)
inlineprotected

Definition at line 369 of file ccontour.

370 {
371  double f11, f12, f21, f22, f33;
372  int x3, y3, i, j;
373 
374  if ((x1 == x2) || (y1 == y2)) /* if not a real cell, punt */
375  return;
376  f11 = Field(x1, y1);
377  f12 = Field(x1, y2);
378  f21 = Field(x2, y1);
379  f22 = Field(x2, y2);
380  if ((x2 > x1+1) || (y2 > y1+1)) { /* is cell divisible? */
381  x3 = (x1+x2)/2;
382  y3 = (y1+y2)/2;
383  f33 = Field(x3, y3);
384  i = j = 0;
385  if (f33 < f11) i++; else if (f33 > f11) j++;
386  if (f33 < f12) i++; else if (f33 > f12) j++;
387  if (f33 < f21) i++; else if (f33 > f21) j++;
388  if (f33 < f22) i++; else if (f33 > f22) j++;
389  if ((i > 2) || (j > 2)) /* should we divide cell? */
390  {
391  /* subdivide cell */
392  Cntr1(x1, x3, y1, y3);
393  Cntr1(x3, x2, y1, y3);
394  Cntr1(x1, x3, y3, y2);
395  Cntr1(x3, x2, y3, y2);
396  return;
397  }
398  }
399  /* install cell in array */
400  FnctData(x1,y2)->m_sBotLen = FnctData(x1,y1)->m_sTopLen = x2-x1;
401  FnctData(x2,y1)->m_sLeftLen = FnctData(x1,y1)->m_sRightLen = y2-y1;
402 }

◆ ExportLine()

virtual void tools::ccontour::ExportLine ( int  iPlane,
int  x1,
int  y1,
int  x2,
int  y2 
)
protectedpure virtual

Implemented in tools::clist_contour.

◆ Field()

double tools::ccontour::Field ( int  x,
int  y 
)
inlineprotected

Definition at line 589 of file ccontour.

590 {
591  double x1, y1;
592 
593  if (FnctData(x,y)->m_sTopLen != -1) /* is it already in the array */
594  return(FnctData(x,y)->m_dFnVal);
595 
596  /* not in the array, create new array element */
597  x1 = m_pLimits[0]+m_dDx*x;
598  y1 = m_pLimits[2]+m_dDy*y;
599  FnctData(x,y)->m_sTopLen = 0;
600  FnctData(x,y)->m_sBotLen = 0;
601  FnctData(x,y)->m_sRightLen = 0;
602  FnctData(x,y)->m_sLeftLen = 0;
603  return (FnctData(x,y)->m_dFnVal = (*m_pFieldFcn)(x1, y1,m_pFieldFcnData));
604 }

◆ FnctData()

CFnStr* tools::ccontour::FnctData ( int  i,
int  j 
)
inlineprotected

Definition at line 183 of file ccontour.

183 { return (m_ppFnData[i]+j);};

◆ generate()

void tools::ccontour::generate ( )
inlinevirtual

Reimplemented in tools::clist_contour.

Definition at line 277 of file ccontour.

278 {
279 
280  int i, j;
281  int x3, x4, y3, y4, x, y, oldx3, xlow;
282  const int cols=m_iColSec+1;
283  const int rows=m_iRowSec+1;
284  //double xoff,yoff;
285 
286  // Initialize memroy if needed
287  InitMemory();
288 
289  m_dDx = (m_pLimits[1]-m_pLimits[0])/(double)(m_iColSec);
290  //xoff = m_pLimits[0];
291  m_dDy = (m_pLimits[3]-m_pLimits[2])/(double)(m_iRowSec);
292  //yoff = m_pLimits[2];
293 
294  xlow = 0;
295  oldx3 = 0;
296  x3 = (cols-1)/m_iRowFir;
297  x4 = ( 2*(cols-1) )/m_iRowFir;
298  for (x = oldx3; x <= x4; x++)
299  { /* allocate new columns needed
300  */
301  if (x >= cols)
302  break;
303  if (m_ppFnData[x]==NULL)
304  m_ppFnData[x] = new CFnStr[rows];
305 
306  for (y = 0; y < rows; y++)
307  FnctData(x,y)->m_sTopLen = -1;
308  }
309 
310  y4 = 0;
311  for (j = 0; j < m_iColFir; j++)
312  {
313  y3 = y4;
314  y4 = ((j+1)*(rows-1))/m_iColFir;
315  Cntr1(oldx3, x3, y3, y4);
316  }
317 
318  for (i = 1; i < m_iRowFir; i++)
319  {
320  y4 = 0;
321  for (j = 0; j < m_iColFir; j++)
322  {
323  y3 = y4;
324  y4 = ((j+1)*(rows-1))/m_iColFir;
325  Cntr1(x3, x4, y3, y4);
326  }
327 
328  y4 = 0;
329  for (j = 0; j < m_iColFir; j++)
330  {
331  y3 = y4;
332  y4 = ((j+1)*(rows-1))/m_iColFir;
333  Pass2(oldx3,x3,y3,y4);
334  }
335 
336  if (i < (m_iRowFir-1))
337  { /* re-use columns no longer needed */
338  oldx3 = x3;
339  x3 = x4;
340  x4 = ((i+2)*(cols-1))/m_iRowFir;
341  for (x = x3+1; x <= x4; x++)
342  {
343  if (xlow < oldx3)
344  {
345  if (m_ppFnData[x])
346  delete[] m_ppFnData[x];
347  m_ppFnData[x] = m_ppFnData[xlow];
348  m_ppFnData[ xlow++ ] = NULL;
349  }
350  else
351  if (m_ppFnData[x]==NULL)
352  m_ppFnData[x] = new CFnStr[rows];
353 
354  for (y = 0; y < rows; y++)
355  FnctData(x,y)->m_sTopLen = -1;
356  }
357  }
358  }
359 
360  y4 = 0;
361  for (j = 0; j < m_iColFir; j++)
362  {
363  y3 = y4;
364  y4 = ((j+1)*(rows-1))/m_iColFir;
365  Pass2(x3,x4,y3,y4);
366  }
367 }

◆ get_limits()

void tools::ccontour::get_limits ( double  pLimits[4])
inline

Definition at line 645 of file ccontour.

646 {
647  for (int i=0;i<4;i++)
648  {
649  pLimits[i]=m_pLimits[i];
650  }
651 }

◆ get_number_of_planes()

size_t tools::ccontour::get_number_of_planes ( ) const
inline

Definition at line 106 of file ccontour.

106 { return m_vPlanes.size();};

◆ get_plane()

double tools::ccontour::get_plane ( unsigned int  i) const
inline

Definition at line 654 of file ccontour.

654  {
655  /*_ASSERT_(i>=0);*/
656  _ASSERT_(i<m_vPlanes.size(),"ccontour::get_plane");
657  return m_vPlanes[i];
658 }

◆ get_planes()

const std::vector<double>& tools::ccontour::get_planes ( ) const
inline

Definition at line 107 of file ccontour.

107 { return m_vPlanes;};

◆ get_xi()

double tools::ccontour::get_xi ( int  i) const
inline

Definition at line 111 of file ccontour.

111 { return m_pLimits[0] + i%(m_iColSec+1)*(m_pLimits[1]-m_pLimits[0])/(double)( m_iColSec );};

◆ get_yi()

double tools::ccontour::get_yi ( int  i) const
inline

Definition at line 660 of file ccontour.

660  {
661  if(i<0) ::printf("ccontour::get_yi : %d\n",i);
662  _ASSERT_(i>=0,"ccontour::get_yi");
663  return m_pLimits[2] + i/(m_iColSec+1)*(m_pLimits[3]-m_pLimits[2])/(double)( m_iRowSec );
664 }

◆ GetColFir()

int tools::ccontour::GetColFir ( ) const
inlineprotected

Definition at line 119 of file ccontour.

119 { return m_iColFir;};

◆ GetColSec()

int tools::ccontour::GetColSec ( ) const
inlineprotected

Definition at line 121 of file ccontour.

121 { return m_iColSec;};

◆ GetRowFir()

int tools::ccontour::GetRowFir ( ) const
inlineprotected

Definition at line 120 of file ccontour.

120 { return m_iRowFir;};

◆ GetRowSec()

int tools::ccontour::GetRowSec ( ) const
inlineprotected

Definition at line 122 of file ccontour.

122 { return m_iRowSec;};

◆ InitMemory()

void tools::ccontour::InitMemory ( )
inlineprotectedvirtual

Reimplemented in tools::clist_contour.

Definition at line 250 of file ccontour.

251 {
252  if (!m_ppFnData)
253  {
254  m_ppFnData=new CFnStr*[m_iColSec+1];
255  for (int i=0;i<m_iColSec+1;i++)
256  {
257  m_ppFnData[i]=NULL;
258  }
259  }
260 }

◆ Pass2()

void tools::ccontour::Pass2 ( int  x1,
int  x2,
int  y1,
int  y2 
)
inlineprotected

Definition at line 404 of file ccontour.

405 {
406  int left = 0, right = 0, top = 0, bot = 0,old, iNew, i, j, x3, y3;
407  double yy0 = 0, yy1 = 0, xx0 = 0, xx1 = 0, xx3, yy3;
408  double v, f11, f12, f21, f22, f33, fold, fnew, f;
409  double xoff=m_pLimits[0];
410  double yoff=m_pLimits[2];
411 
412  if ((x1 == x2) || (y1 == y2)) /* if not a real cell, punt */
413  return;
414  f11 = FnctData(x1,y1)->m_dFnVal;
415  f12 = FnctData(x1,y2)->m_dFnVal;
416  f21 = FnctData(x2,y1)->m_dFnVal;
417  f22 = FnctData(x2,y2)->m_dFnVal;
418  if ((x2 > x1+1) || (y2 > y1+1)) /* is cell divisible? */
419  {
420  x3 = (x1+x2)/2;
421  y3 = (y1+y2)/2;
422  f33 = FnctData(x3, y3)->m_dFnVal;
423  i = j = 0;
424  if (f33 < f11) i++; else if (f33 > f11) j++;
425  if (f33 < f12) i++; else if (f33 > f12) j++;
426  if (f33 < f21) i++; else if (f33 > f21) j++;
427  if (f33 < f22) i++; else if (f33 > f22) j++;
428  if ((i > 2) || (j > 2)) /* should we divide cell? */
429  {
430  /* subdivide cell */
431  Pass2(x1, x3, y1, y3);
432  Pass2(x3, x2, y1, y3);
433  Pass2(x1, x3, y3, y2);
434  Pass2(x3, x2, y3, y2);
435  return;
436  }
437  }
438 
439  for (i = 0; i < (int)m_vPlanes.size(); i++)
440  {
441  v = m_vPlanes[i];
442  j = 0;
443  if (f21 > v) j++;
444  if (f11 > v) j |= 2;
445  if (f22 > v) j |= 4;
446  if (f12 > v) j |= 010;
447  if ((f11 > v) ^ (f12 > v))
448  {
449  if ((FnctData(x1,y1)->m_sLeftLen != 0) &&
450  (FnctData(x1,y1)->m_sLeftLen < FnctData(x1,y1)->m_sRightLen))
451  {
452  old = y1;
453  fold = f11;
454  while (1)
455  {
456  iNew = old+FnctData(x1,old)->m_sLeftLen;
457  fnew = FnctData(x1,iNew)->m_dFnVal;
458  if ((fnew > v) ^ (fold > v))
459  break;
460  old = iNew;
461  fold = fnew;
462  }
463  yy0 = ((old-y1)+(iNew-old)*(v-fold)/(fnew-fold))/(y2-y1);
464  }
465  else
466  yy0 = (v-f11)/(f12-f11);
467 
468  left = (int)(y1+(y2-y1)*yy0+0.5);
469  }
470  if ((f21 > v) ^ (f22 > v))
471  {
472  if ((FnctData(x2,y1)->m_sRightLen != 0) &&
473  (FnctData(x2,y1)->m_sRightLen < FnctData(x2,y1)->m_sLeftLen))
474  {
475  old = y1;
476  fold = f21;
477  while (1)
478  {
479  iNew = old+FnctData(x2,old)->m_sRightLen;
480  fnew = FnctData(x2,iNew)->m_dFnVal;
481  if ((fnew > v) ^ (fold > v))
482  break;
483  old = iNew;
484  fold = fnew;
485  }
486  yy1 = ((old-y1)+(iNew-old)*(v-fold)/(fnew-fold))/(y2-y1);
487  }
488  else
489  yy1 = (v-f21)/(f22-f21);
490 
491  right = (int)(y1+(y2-y1)*yy1+0.5);
492  }
493  if ((f21 > v) ^ (f11 > v))
494  {
495  if ((FnctData(x1,y1)->m_sBotLen != 0) &&
496  (FnctData(x1,y1)->m_sBotLen < FnctData(x1,y1)->m_sTopLen)) {
497  old = x1;
498  fold = f11;
499  while (1) {
500  iNew = old+FnctData(old,y1)->m_sBotLen;
501  fnew = FnctData(iNew,y1)->m_dFnVal;
502  if ((fnew > v) ^ (fold > v))
503  break;
504  old = iNew;
505  fold = fnew;
506  }
507  xx0 = ((old-x1)+(iNew-old)*(v-fold)/(fnew-fold))/(x2-x1);
508  }
509  else
510  xx0 = (v-f11)/(f21-f11);
511 
512  bot = (int)(x1+(x2-x1)*xx0+0.5);
513  }
514  if ((f22 > v) ^ (f12 > v))
515  {
516  if ((FnctData(x1,y2)->m_sTopLen != 0) &&
517  (FnctData(x1,y2)->m_sTopLen < FnctData(x1,y2)->m_sBotLen)) {
518  old = x1;
519  fold = f12;
520  while (1) {
521  iNew = old+FnctData(old,y2)->m_sTopLen;
522  fnew = FnctData(iNew,y2)->m_dFnVal;
523  if ((fnew > v) ^ (fold > v))
524  break;
525  old = iNew;
526  fold = fnew;
527  }
528  xx1 = ((old-x1)+(iNew-old)*(v-fold)/(fnew-fold))/(x2-x1);
529  }
530  else
531  xx1 = (v-f12)/(f22-f12);
532 
533  top = (int)(x1+(x2-x1)*xx1+0.5);
534  }
535 
536  switch (j)
537  {
538  case 7:
539  case 010:
540  ExportLine(i,x1,left,top,y2);
541  break;
542  case 5:
543  case 012:
544  ExportLine(i,bot,y1,top,y2);
545  break;
546  case 2:
547  case 015:
548  ExportLine(i,x1,left,bot,y1);
549  break;
550  case 4:
551  case 013:
552  ExportLine(i,top,y2,x2,right);
553  break;
554  case 3:
555  case 014:
556  ExportLine(i,x1,left,x2,right);
557  break;
558  case 1:
559  case 016:
560  ExportLine(i,bot,y1,x2,right);
561  break;
562  case 0:
563  case 017:
564  break;
565  case 6:
566  case 011:
567  yy3 = (xx0*(yy1-yy0)+yy0)/(1.0-(xx1-xx0)*(yy1-yy0));
568  xx3 = yy3*(xx1-xx0)+xx0;
569  xx3 = x1+xx3*(x2-x1);
570  yy3 = y1+yy3*(y2-y1);
571  xx3 = xoff+xx3*m_dDx;
572  yy3 = yoff+yy3*m_dDy;
573  f = (*m_pFieldFcn)(xx3, yy3,m_pFieldFcnData);
574  if (f == v) {
575  ExportLine(i,bot,y1,top,y2);
576  ExportLine(i,x1,left,x2,right);
577  } else
578  if (((f > v) && (f22 > v)) || ((f < v) && (f22 < v))) {
579  ExportLine(i,x1,left,top,y2);
580  ExportLine(i,bot,y1,x2,right);
581  } else {
582  ExportLine(i,x1,left,bot,y1);
583  ExportLine(i,top,y2,x2,right);
584  }
585  }
586  }
587 }

◆ set_field_fcn()

void tools::ccontour::set_field_fcn ( double(*)(double, double, void *)  _pFieldFcn,
void *  aData 
)
inline

Definition at line 614 of file ccontour.

615 {
616  m_pFieldFcnData = aData;
617  m_pFieldFcn=_pFieldFcn;
618 }

◆ set_first_grid()

void tools::ccontour::set_first_grid ( int  iCol,
int  iRow 
)
inline

Definition at line 620 of file ccontour.

621 {
622  m_iColFir=mx<int>(iCol,2);
623  m_iRowFir=mx<int>(iRow,2);
624 }

◆ set_limits()

void tools::ccontour::set_limits ( double  pLimits[4])
inline

Definition at line 635 of file ccontour.

636 {
637  _ASSERT_(pLimits[0]<pLimits[1],"ccontour::set_limits");
638  _ASSERT_(pLimits[2]<pLimits[3],"ccontour::set_limits");
639  for (int i=0;i<4;i++)
640  {
641  m_pLimits[i]=pLimits[i];
642  }
643 }

◆ set_planes()

void tools::ccontour::set_planes ( const std::vector< double > &  vPlanes)
inline

Definition at line 606 of file ccontour.

607 {
608  // cleaning memory
609  CleanMemory();
610 
611  m_vPlanes = vPlanes;
612 }

◆ set_secondary_grid()

void tools::ccontour::set_secondary_grid ( int  iCol,
int  iRow 
)
inline

Definition at line 626 of file ccontour.

627 {
628  // cleaning work matrices if allocated
629  CleanMemory();
630 
631  m_iColSec=mx<int>(iCol,2);
632  m_iRowSec=mx<int>(iRow,2);
633 }

Member Data Documentation

◆ m_dDx

double tools::ccontour::m_dDx
protected

Definition at line 180 of file ccontour.

◆ m_dDy

double tools::ccontour::m_dDy
protected

Definition at line 181 of file ccontour.

◆ m_iColFir

int tools::ccontour::m_iColFir
protected

Definition at line 169 of file ccontour.

◆ m_iColSec

int tools::ccontour::m_iColSec
protected

Definition at line 171 of file ccontour.

◆ m_iRowFir

int tools::ccontour::m_iRowFir
protected

Definition at line 170 of file ccontour.

◆ m_iRowSec

int tools::ccontour::m_iRowSec
protected

Definition at line 172 of file ccontour.

◆ m_pFieldFcn

double(* tools::ccontour::m_pFieldFcn) (double x, double y, void *)
protected

Definition at line 174 of file ccontour.

◆ m_pFieldFcnData

void* tools::ccontour::m_pFieldFcnData
protected

Definition at line 173 of file ccontour.

◆ m_pLimits

double tools::ccontour::m_pLimits[4]
protected

Definition at line 168 of file ccontour.

◆ m_ppFnData

CFnStr** tools::ccontour::m_ppFnData
protected

Definition at line 182 of file ccontour.

◆ m_vPlanes

std::vector<double> tools::ccontour::m_vPlanes
protected

Definition at line 167 of file ccontour.

The documentation for this class was generated from the following file:
tools::ccontour::m_iRowFir
int m_iRowFir
Definition: ccontour:170
tools::ccontour::FnctData
CFnStr * FnctData(int i, int j)
Definition: ccontour:183
tools::ccontour::m_dDx
double m_dDx
Definition: ccontour:180
tools::ccontour::Cntr1
void Cntr1(int x1, int x2, int y1, int y2)
Definition: ccontour:369
tools::ccontour::m_iColFir
int m_iColFir
Definition: ccontour:169
tools::ccontour::InitMemory
virtual void InitMemory()
Definition: ccontour:250
tools::sg::right
@ right
Definition: enums:76
tools::ccontour::Pass2
void Pass2(int x1, int x2, int y1, int y2)
Definition: ccontour:404
tools::ccontour::m_dDy
double m_dDy
Definition: ccontour:181
tools::sg::top
@ top
Definition: enums:82
tools::ccontour::CleanMemory
virtual void CleanMemory()
Definition: ccontour:262
tools::sg::left
@ left
Definition: enums:74
tools::ccontour::Field
double Field(int x, int y)
Definition: ccontour:589
tools::ccontour::m_pFieldFcn
double(* m_pFieldFcn)(double x, double y, void *)
Definition: ccontour:174
tools::ccontour::m_ppFnData
CFnStr ** m_ppFnData
Definition: ccontour:182
tools::ccontour::m_iColSec
int m_iColSec
Definition: ccontour:171
tools::ccontour::m_iRowSec
int m_iRowSec
Definition: ccontour:172
tools::ccontour::ExportLine
virtual void ExportLine(int iPlane, int x1, int y1, int x2, int y2)=0
tools::ccontour::m_vPlanes
std::vector< double > m_vPlanes
Definition: ccontour:167
tools::ccontour::m_pLimits
double m_pLimits[4]
Definition: ccontour:168
tools::ccontour::_ASSERT_
static void _ASSERT_(bool a_what, const char *a_where)
Definition: ccontour:197
tools::ccontour::m_pFieldFcnData
void * m_pFieldFcnData
Definition: ccontour:173
Generated by doxygen 1.8.20