SAGA API  v9.8
grid_system.cpp
Go to the documentation of this file.
1 
3 // //
4 // SAGA //
5 // //
6 // System for Automated Geoscientific Analyses //
7 // //
8 // Application Programming Interface //
9 // //
10 // Library: SAGA_API //
11 // //
12 //-------------------------------------------------------//
13 // //
14 // grid_system.cpp //
15 // //
16 // Copyright (C) 2005 by Olaf Conrad //
17 // //
18 //-------------------------------------------------------//
19 // //
20 // This file is part of 'SAGA - System for Automated //
21 // Geoscientific Analyses'. //
22 // //
23 // This library is free software; you can redistribute //
24 // it and/or modify it under the terms of the GNU Lesser //
25 // General Public License as published by the Free //
26 // Software Foundation, either version 2.1 of the //
27 // License, or (at your option) any later version. //
28 // //
29 // This library is distributed in the hope that it will //
30 // be useful, but WITHOUT ANY WARRANTY; without even the //
31 // implied warranty of MERCHANTABILITY or FITNESS FOR A //
32 // PARTICULAR PURPOSE. See the GNU Lesser General Public //
33 // License for more details. //
34 // //
35 // You should have received a copy of the GNU Lesser //
36 // General Public License along with this program; if //
37 // not, see <http://www.gnu.org/licenses/>. //
38 // //
39 //-------------------------------------------------------//
40 // //
41 // contact: Olaf Conrad //
42 // Institute of Geography //
43 // University Hamburg //
44 // Germany //
45 // //
46 // e-mail: oconrad@saga-gis.org //
47 // //
49 
50 //---------------------------------------------------------
51 #include "grid.h"
52 #include "shapes.h"
53 #include "parameters.h"
54 
55 
57 // //
58 // //
59 // //
61 
62 //---------------------------------------------------------
66 //
67 int CSG_Grid_System::m_Precision = 16;
68 
69 //---------------------------------------------------------
75 int CSG_Grid_System::Set_Precision(int Decimals)
76 {
77  m_Precision = Decimals;
78 
79  return( m_Precision );
80 }
81 
82 //---------------------------------------------------------
88 int CSG_Grid_System::Get_Precision(void)
89 {
90  return( m_Precision );
91 }
92 
93 
95 // //
97 
98 //---------------------------------------------------------
99 CSG_Grid_System::CSG_Grid_System(void)
100 {
101  Destroy();
102 }
103 
104 //---------------------------------------------------------
105 CSG_Grid_System::CSG_Grid_System(const CSG_Grid_System &System, int Precision)
106 {
107  Create(System, Precision);
108 }
109 
110 //---------------------------------------------------------
111 CSG_Grid_System::CSG_Grid_System(double Cellsize, const CSG_Rect &Extent, int Precision)
112 {
113  Create(Cellsize, Extent, Precision);
114 }
115 
116 //---------------------------------------------------------
117 CSG_Grid_System::CSG_Grid_System(double Cellsize, double xMin, double yMin, double xMax, double yMax, int Precision)
118 {
119  Create(Cellsize, xMin, yMin, xMax, yMax, Precision);
120 }
121 
122 //---------------------------------------------------------
123 CSG_Grid_System::CSG_Grid_System(double Cellsize, double xMin, double yMin, int NX, int NY, int Precision)
124 {
125  Create(Cellsize, xMin, yMin, NX, NY, Precision);
126 }
127 
128 //---------------------------------------------------------
129 CSG_Grid_System::CSG_Grid_System(const CSG_String &System, int Precision)
130 {
131  Create(System, Precision);
132 }
133 
134 //---------------------------------------------------------
135 CSG_Grid_System::~CSG_Grid_System(void)
136 {
137  Destroy();
138 }
139 
140 
142 // //
144 
145 //---------------------------------------------------------
146 bool CSG_Grid_System::Create(const CSG_Grid_System &System, int Precision)
147 {
148  if( Precision >= 0 )
149  {
150  return( Create(System.Get_Cellsize(), System.Get_XMin(), System.Get_YMin(), System.Get_NX(), System.Get_NY(), Precision) );
151  }
152 
153  m_NX = System.m_NX;
154  m_NY = System.m_NY;
155  m_NCells = System.m_NCells;
156 
157  m_Cellsize = System.m_Cellsize;
158  m_Cellarea = System.m_Cellarea;
159  m_Diagonal = System.m_Diagonal;
160 
161  m_Extent = System.m_Extent;
162  m_Extent_Cells = System.m_Extent_Cells;
163 
164  return( is_Valid() );
165 }
166 
167 //---------------------------------------------------------
168 bool CSG_Grid_System::Create(double Cellsize, const CSG_Rect &Extent, int Precision)
169 {
170  if( Cellsize > 0. && Extent.Get_XRange() >= 0. && Extent.Get_YRange() >= 0. )
171  {
172  int nx = 1 + (int)(0.5 + Extent.Get_XRange() / Cellsize);
173  int ny = 1 + (int)(0.5 + Extent.Get_YRange() / Cellsize);
174 
175  double x = fabs(Cellsize - Extent.Get_XRange() / (nx - 1.)) <= 0. ? Extent.Get_XMin() : Extent.Get_Center().x - Cellsize * (nx - 1.) / 2.;
176  double y = fabs(Cellsize - Extent.Get_YRange() / (ny - 1.)) <= 0. ? Extent.Get_YMin() : Extent.Get_Center().y - Cellsize * (ny - 1.) / 2.;
177 
178  return( Create(Cellsize, x, y, nx, ny, Precision) );
179  }
180 
181  Destroy();
182 
183  return( false );
184 }
185 
186 //---------------------------------------------------------
187 bool CSG_Grid_System::Create(double Cellsize, double xMin, double yMin, double xMax, double yMax, int Precision)
188 {
189  return( Create(Cellsize, CSG_Rect(xMin, yMin, xMax, yMax), Precision) );
190 }
191 
192 //---------------------------------------------------------
193 bool CSG_Grid_System::Create(double Cellsize, double xMin, double yMin, int NX, int NY, int Precision)
194 {
195  if( Cellsize > 0. && NX > 0 && NY > 0 )
196  {
197  Cellsize = SG_Get_Rounded(Cellsize, Precision == -1 ? m_Precision : Precision);
198  xMin = SG_Get_Rounded(xMin , Precision == -1 ? m_Precision : Precision);
199  yMin = SG_Get_Rounded(yMin , Precision == -1 ? m_Precision : Precision);
200 
201  if( Cellsize > 0. )
202  {
203  m_NX = NX;
204  m_NY = NY;
205  m_NCells = (sLong)NY * NX;
206 
207  m_Cellsize = Cellsize;
208  m_Cellarea = Cellsize * Cellsize;
209  m_Diagonal = Cellsize * sqrt(2.);
210 
211  m_Extent.xMin = xMin;
212  m_Extent.yMin = yMin;
213  m_Extent.xMax = xMin + (NX - 1.) * Cellsize;
214  m_Extent.yMax = yMin + (NY - 1.) * Cellsize;
215 
216  m_Extent_Cells = m_Extent;
217  m_Extent_Cells.Inflate(0.5 * Cellsize, false);
218 
219  return( true );
220  }
221  }
222 
223  Destroy();
224 
225  return( false );
226 }
227 
228 //---------------------------------------------------------
235 bool CSG_Grid_System::Create(const CSG_String &System, int Precision)
236 {
237  double Cellsize, xMin, yMin; int NX, NY; CSG_Strings Values;
238 
239  // 1 2 3 4
240  // "%.*f; %d; %d; %.*f; %.*fy"
241  Values = SG_String_Tokenize(System, ";");
242 
243  if( Values.Get_Count() == 5 && Values[0].asDouble(Cellsize) && Values[1].asInt(NX) && Values[2].asInt(NY) && Values[3].asDouble(xMin) && Values[4].asDouble(yMin) )
244  {
245  return( Create(Cellsize, xMin, yMin, NX, NY, Precision) );
246  }
247 
248  // 1 2 3 4
249  // "%.*f; %dx %dy; %.*fx %.*fy"
250  Values = SG_String_Tokenize(System, ";x");
251 
252  if( Values.Get_Count() == 5 && Values[0].asDouble(Cellsize) && Values[1].asInt(NX) && Values[2].asInt(NY) && Values[3].asDouble(xMin) && Values[4].asDouble(yMin) )
253  {
254  return( Create(Cellsize, xMin, yMin, NX, NY, Precision) );
255  }
256 
257  // 1 2 3 4 5 6 7
258  // "%s: %f, %s: %dx/%dy, %s: %fx/%fy"
259  Values = SG_String_Tokenize(System, ":,/");
260 
261  if( Values.Get_Count() == 8 && Values[1].asDouble(Cellsize) && Values[3].asInt(NX) && Values[4].asInt(NY) && Values[6].asDouble(xMin) && Values[7].asDouble(yMin) )
262  {
263  return( Create(Cellsize, xMin, yMin, NX, NY, Precision) );
264  }
265 
266  return( false );
267 }
268 
269 //---------------------------------------------------------
270 bool CSG_Grid_System::Destroy(void)
271 {
272  m_NX = 0;
273  m_NY = 0;
274  m_NCells = 0;
275 
276  m_Cellsize = 0.;
277  m_Cellarea = 0.;
278  m_Diagonal = 0.;
279 
280  m_Extent .Create(0., 0., 0., 0.);
281  m_Extent_Cells.Create(0., 0., 0., 0.);
282 
283  return( true );
284 }
285 
286 //---------------------------------------------------------
287 bool CSG_Grid_System::Assign(const CSG_Grid_System &System)
288 { return( Create(System) ); }
289 
290 bool CSG_Grid_System::Assign(double Cellsize, const CSG_Rect &Extent)
291 { return( Create(Cellsize, Extent) ); }
292 
293 bool CSG_Grid_System::Assign(double Cellsize, double xMin, double yMin, double xMax, double yMax)
294 { return( Create(Cellsize, xMin, yMin, xMax, yMax) ); }
295 
296 bool CSG_Grid_System::Assign(double Cellsize, double xMin, double yMin, int NX, int NY)
297 { return( Create(Cellsize, xMin, yMin, NX, NY) ); }
298 
299 
301 // //
303 
304 //---------------------------------------------------------
305 bool CSG_Grid_System::is_Valid(void) const
306 {
307  return( m_Cellsize > 0. && m_NX > 0 && m_NY > 0 );
308 }
309 
310 //---------------------------------------------------------
311 const SG_Char * CSG_Grid_System::Get_Name(bool bShort)
312 {
313  if( is_Valid() )
314  {
315  if( bShort )
316  {
317  m_Name.Printf("%.*f; %dx %dy; %.*fx %.*fy",
318  SG_Get_Significant_Decimals(m_Cellsize ), m_Cellsize, m_NX, m_NY,
319  SG_Get_Significant_Decimals(m_Extent.xMin), m_Extent.xMin,
320  SG_Get_Significant_Decimals(m_Extent.yMin), m_Extent.yMin
321  );
322  }
323  else
324  {
325  m_Name.Printf("%s: %f, %s: %dx/%dy, %s: %fx/%fy",
326  _TL("Cell size" ), m_Cellsize,
327  _TL("Number of cells" ), m_NX, m_NY,
328  _TL("Lower left cell center"), m_Extent.xMin, m_Extent.yMin
329  );
330  }
331  }
332  else
333  {
334  m_Name = _TL("<not set>");
335  }
336 
337  return( m_Name );
338 }
339 
340 //---------------------------------------------------------
341 const SG_Char * CSG_Grid_System::asString(void)
342 {
343  m_Name.Printf("%.*f; %d; %d; %.*f; %.*f",
344  SG_Get_Significant_Decimals(m_Cellsize ), m_Cellsize, m_NX, m_NY,
345  SG_Get_Significant_Decimals(m_Extent.xMin), m_Extent.xMin,
346  SG_Get_Significant_Decimals(m_Extent.yMin), m_Extent.yMin
347  );
348 
349  return( m_Name );
350 }
351 
352 
354 // //
356 
357 //---------------------------------------------------------
358 CSG_Grid_System & CSG_Grid_System::operator = (const CSG_Grid_System &System)
359 {
360  Create(System);
361 
362  return( *this );
363 }
364 
365 //---------------------------------------------------------
366 bool CSG_Grid_System::operator == (const CSG_Grid_System *pSystem) const
367 {
368  return( pSystem != NULL && is_Equal(*pSystem) == true );
369 }
370 
371 bool CSG_Grid_System::operator != (const CSG_Grid_System *pSystem) const
372 {
373  return( pSystem == NULL || is_Equal(*pSystem) == false );
374 }
375 
376 //---------------------------------------------------------
377 bool CSG_Grid_System::operator == (const CSG_Grid_System &System) const
378 {
379  return( is_Equal(System) == true );
380 }
381 
382 bool CSG_Grid_System::operator != (const CSG_Grid_System &System) const
383 {
384  return( is_Equal(System) == false );
385 }
386 
387 
389 // //
391 
392 //---------------------------------------------------------
393 bool CSG_Grid_System::is_Equal(const CSG_Grid_System &System) const
394 {
395  return( m_Cellsize == System.m_Cellsize
396  && m_NX == System.m_NX
397  && m_NY == System.m_NY
398  && m_Extent.xMin == System.m_Extent.xMin
399  && m_Extent.yMin == System.m_Extent.yMin
400  );
401 }
402 
403 //---------------------------------------------------------
404 bool CSG_Grid_System::is_Equal(double Cellsize, const TSG_Rect &Extent) const
405 {
406  return( m_Cellsize == Cellsize && m_Extent == Extent );
407 }
408 
409 
411 // //
412 // //
413 // //
415 
416 //---------------------------------------------------------
417 CSG_Grid_Cell_Addressor::CSG_Grid_Cell_Addressor(void)
418 {
419  m_Kernel.Add_Field("X", SG_DATATYPE_Int );
420  m_Kernel.Add_Field("Y", SG_DATATYPE_Int );
421  m_Kernel.Add_Field("D", SG_DATATYPE_Double);
422  m_Kernel.Add_Field("W", SG_DATATYPE_Double);
423 }
424 
425 //---------------------------------------------------------
426 bool CSG_Grid_Cell_Addressor::Destroy(void)
427 {
428  m_Kernel.Del_Records();
429 
430  m_Radius = 1.;
431  m_Radius_0 = 0.;
432  m_Direction = 0.;
433  m_Tolerance = 0.;
434 
435  return( true );
436 }
437 
438 
440 // //
442 
443 //---------------------------------------------------------
444 bool CSG_Grid_Cell_Addressor::Add_Parameters(CSG_Parameters &Parameters, const CSG_String &Parent, int Style)
445 {
446  CSG_String Types;
447 
448  if( (Style & SG_GRIDCELLADDR_PARM_SQUARE ) != 0 )
449  {
450  Types += CSG_String::Format("{%d}%s|", SG_GRIDCELLADDR_PARM_SQUARE , _TL("Square" ));
451  }
452 
453  if( (Style & SG_GRIDCELLADDR_PARM_CIRCLE ) != 0 )
454  {
455  Types += CSG_String::Format("{%d}%s|", SG_GRIDCELLADDR_PARM_CIRCLE , _TL("Circle" ));
456  }
457 
458  if( (Style & SG_GRIDCELLADDR_PARM_ANNULUS) != 0 )
459  {
460  Types += CSG_String::Format("{%d}%s|", SG_GRIDCELLADDR_PARM_ANNULUS, _TL("Annulus"));
461  }
462 
463  if( (Style & SG_GRIDCELLADDR_PARM_SECTOR ) != 0 )
464  {
465  Types += CSG_String::Format("{%d}%s|", SG_GRIDCELLADDR_PARM_SECTOR , _TL("Sector" ));
466  }
467 
468  Parameters.Add_Choice(Parent, "KERNEL_TYPE", _TL("Kernel Type"),
469  _TL("The kernel's shape."),
470  Types, 1
471  );
472 
473  Parameters.Set_Enabled("KERNEL_TYPE", Parameters("KERNEL_TYPE")->asChoice()->Get_Count() > 1);
474 
475  //-----------------------------------------------------
476  CSG_String Unit_Radius((Style & SG_GRIDCELLADDR_PARM_MAPUNIT) == 0 ? _TL("cells") : _TL("map units"));
477 
478  if( (Style & SG_GRIDCELLADDR_PARM_SIZEDBL) != 0 )
479  {
480  if( (Style & SG_GRIDCELLADDR_PARM_ANNULUS) != 0 )
481  {
482  Parameters.Add_Double("KERNEL_TYPE", "KERNEL_INNER" , _TL("Inner Radius"), Unit_Radius, 0., 0., true);
483  }
484 
485  Parameters .Add_Double("KERNEL_TYPE", "KERNEL_RADIUS", _TL( "Radius"), Unit_Radius, 1., 0., true);
486  }
487  else
488  {
489  if( (Style & SG_GRIDCELLADDR_PARM_ANNULUS) != 0 )
490  {
491  Parameters.Add_Int ("KERNEL_TYPE", "KERNEL_INNER" , _TL("Inner Radius"), Unit_Radius, 0 , 0 , true);
492  }
493 
494  Parameters .Add_Int ("KERNEL_TYPE", "KERNEL_RADIUS", _TL( "Radius"), Unit_Radius, 2 , 0 , true);
495  }
496 
497  //-----------------------------------------------------
498  if( (Style & SG_GRIDCELLADDR_PARM_SECTOR) != 0 )
499  {
500  Parameters.Add_Double("KERNEL_TYPE", "KERNEL_DIRECTION", _TL("Direction"), _TL("degree"), 0., -360., true, 360., true);
501  Parameters.Add_Double("KERNEL_TYPE", "KERNEL_TOLERANCE", _TL("Tolerance"), _TL("degree"), 5., 0., true, 180., true);
502  }
503 
504  if( (Style & SG_GRIDCELLADDR_PARM_WEIGHTING) != 0 )
505  {
506  CSG_Distance_Weighting::Add_Parameters(Parameters,
507  Parameters("KERNEL_TYPE")->is_Enabled() ? CSG_String("KERNEL_TYPE") : Parent
508  );
509  }
510 
511  return( true );
512 }
513 
514 //---------------------------------------------------------
515 bool CSG_Grid_Cell_Addressor::Set_Parameters(CSG_Parameters &Parameters, int Type)
516 {
517  if( Type == 0 && Parameters("KERNEL_TYPE") )
518  {
519  Parameters("KERNEL_TYPE")->asChoice()->Get_Data(Type);
520  }
521 
522  switch( Type )
523  {
524  case SG_GRIDCELLADDR_PARM_SQUARE:
525  return( Set_Radius(
526  Parameters("KERNEL_RADIUS" )->asDouble(),
527  true
528  ));
529 
530  case SG_GRIDCELLADDR_PARM_CIRCLE:
531  return( Set_Radius(
532  Parameters("KERNEL_RADIUS" )->asDouble(),
533  false
534  ));
535 
536  case SG_GRIDCELLADDR_PARM_ANNULUS:
537  return( Set_Annulus(
538  Parameters("KERNEL_INNER" )->asDouble(),
539  Parameters("KERNEL_RADIUS" )->asDouble()
540  ));
541 
542  case SG_GRIDCELLADDR_PARM_SECTOR:
543  return( Set_Sector(
544  Parameters("KERNEL_RADIUS" )->asDouble(),
545  Parameters("KERNEL_DIRECTION")->asDouble() * M_DEG_TO_RAD,
546  Parameters("KERNEL_TOLERANCE")->asDouble() * M_DEG_TO_RAD
547  ));
548  }
549 
550  return( false );
551 }
552 
553 //---------------------------------------------------------
554 bool CSG_Grid_Cell_Addressor::Set_Square (CSG_Parameters &Parameters) { return( Set_Parameters(Parameters, SG_GRIDCELLADDR_PARM_SQUARE ) ); }
555 bool CSG_Grid_Cell_Addressor::Set_Circle (CSG_Parameters &Parameters) { return( Set_Parameters(Parameters, SG_GRIDCELLADDR_PARM_CIRCLE ) ); }
556 bool CSG_Grid_Cell_Addressor::Set_Annulus(CSG_Parameters &Parameters) { return( Set_Parameters(Parameters, SG_GRIDCELLADDR_PARM_ANNULUS) ); }
557 bool CSG_Grid_Cell_Addressor::Set_Sector (CSG_Parameters &Parameters) { return( Set_Parameters(Parameters, SG_GRIDCELLADDR_PARM_SECTOR ) ); }
558 
559 
561 // //
563 
564 //---------------------------------------------------------
565 bool CSG_Grid_Cell_Addressor::Enable_Parameters(CSG_Parameters &Parameters)
566 {
567  if( Parameters("KERNEL_TYPE") )
568  {
569  int Type = Parameters("KERNEL_TYPE")->asChoice()->Get_Item_Data(Parameters("KERNEL_TYPE")->asInt()).asInt();
570 
571  Parameters.Set_Enabled("KERNEL_INNER" , Type == SG_GRIDCELLADDR_PARM_ANNULUS);
572  Parameters.Set_Enabled("KERNEL_DIRECTION", Type == SG_GRIDCELLADDR_PARM_SECTOR );
573  Parameters.Set_Enabled("KERNEL_TOLERANCE", Type == SG_GRIDCELLADDR_PARM_SECTOR );
574  }
575 
576  CSG_Distance_Weighting::Enable_Parameters(Parameters);
577 
578  return( true );
579 }
580 
581 
583 // //
585 
586 //---------------------------------------------------------
587 bool CSG_Grid_Cell_Addressor::_Set_Kernel(int Type, double Radius, double Radius_Inner, double Direction, double Tolerance)
588 {
589  Destroy();
590 
591  m_Type = Type;
592  m_Radius = Radius;
593  m_Radius_0 = Radius_Inner;
594  m_Direction = fmod(Direction, M_PI_360); if( Direction < 0. ) Direction += M_PI_360;
595  m_Tolerance = fmod(Tolerance, M_PI_180); if( Tolerance < 0. ) Tolerance += M_PI_180;
596 
597  if( m_Radius < 0. || m_Radius < m_Radius_0 )
598  {
599  return( false );
600  }
601 
602  CSG_Vector Sector(2);
603 
604  if( m_Type == 3 ) // sector
605  {
606  Sector[0] = fmod(Direction - Tolerance, M_PI_360); if( Sector[0] < 0. ) Sector[0] += M_PI_360;
607  Sector[1] = fmod(Direction + Tolerance, M_PI_360); if( Sector[1] < 0. ) Sector[1] += M_PI_360;
608  }
609 
610  //-----------------------------------------------------
611  #define ADD_CELL(x, y, Distance) {\
612  CSG_Table_Record &Cell = *Kernel.Add_Record();\
613  Cell.Set_Value(0, x);\
614  Cell.Set_Value(1, y);\
615  Cell.Set_Value(2, Distance);\
616  Cell.Set_Value(3, m_Weighting.Get_Weight(d));\
617  }
618 
619  CSG_Table Kernel(&m_Kernel);
620 
621  int Size = (int)ceil(m_Radius);
622 
623  //-----------------------------------------------------
624  for(int y=-Size; y<=Size; y++)
625  {
626  if( abs(y) > m_Radius )
627  continue;
628 
629  for(int x=-Size; x<=Size; x++)
630  {
631  if( abs(x) > m_Radius )
632  continue;
633 
634  double d = SG_Get_Length(x, y);
635 
636  switch( m_Type )
637  {
638  default: // square
639  ADD_CELL(x, y, d);
640  break;
641 
642  case 1: // circle
643  if( d <= m_Radius )
644  {
645  ADD_CELL(x, y, d);
646  }
647  break;
648 
649  case 2: // annulus
650  if( d <= m_Radius && d >= m_Radius_0 )
651  {
652  ADD_CELL(x, y, d);
653  }
654  break;
655 
656  case 3: // sector
657  if( d <= m_Radius && d >= m_Radius_0 && ((x == 0 && y == 0) || SG_is_Angle_Between(SG_Get_Angle_Of_Direction(x, y), Sector[0], Sector[1], false)) )
658  {
659  ADD_CELL(x, y, d);
660  }
661  break;
662  }
663  }
664  }
665 
666  //-----------------------------------------------------
667  if( Kernel.Get_Count() < 1 )
668  {
669  return( false );
670  }
671 
672  Kernel.Set_Index(2, TABLE_INDEX_Ascending);
673 
674  for(int i=0; i<Kernel.Get_Count(); i++)
675  {
676  m_Kernel.Add_Record(Kernel.Get_Record_byIndex(i));
677  }
678 
679  return( true );
680 }
681 
682 //---------------------------------------------------------
683 bool CSG_Grid_Cell_Addressor::Set_Radius(double Radius, bool bSquare)
684 {
685  return( bSquare ? Set_Square(Radius) : Set_Circle(Radius) );
686 }
687 
688 //---------------------------------------------------------
689 bool CSG_Grid_Cell_Addressor::Set_Square(double Radius)
690 {
691  return( _Set_Kernel(0, Radius, 0., 0., 0.) );
692 }
693 
694 //---------------------------------------------------------
695 bool CSG_Grid_Cell_Addressor::Set_Circle(double Radius)
696 {
697  return( _Set_Kernel(1, Radius, 0., 0., 0.) );
698 }
699 
700 //---------------------------------------------------------
701 bool CSG_Grid_Cell_Addressor::Set_Annulus(double Radius_Inner, double Radius_Outer)
702 {
703  return( _Set_Kernel(2, Radius_Outer, Radius_Inner, 0., 0.) );
704 }
705 
706 //---------------------------------------------------------
707 bool CSG_Grid_Cell_Addressor::Set_Sector(double Radius, double Direction, double Tolerance)
708 {
709  return( _Set_Kernel(3, Radius, 0., Direction, Tolerance) );
710 }
711 
712 
714 // //
715 // //
716 // //
718 
719 //---------------------------------------------------------
M_DEG_TO_RAD
#define M_DEG_TO_RAD
Definition: mat_tools.h:109
CSG_Rect
Definition: geo_tools.h:474
CSG_Grid_System::operator=
CSG_Grid_System & operator=(const CSG_Grid_System &System)
Definition: grid_system.cpp:358
SG_DATATYPE_Int
@ SG_DATATYPE_Int
Definition: api_core.h:1002
CSG_String::Printf
int Printf(const char *Format,...)
Definition: api_string.cpp:308
CSG_Grid_System::Get_Precision
static int Get_Precision(void)
Definition: grid_system.cpp:88
CSG_Grid_System::Get_Cellsize
double Get_Cellsize(void) const
Definition: grid.h:235
_TL
#define _TL(s)
Definition: api_core.h:1556
CSG_Table::Del_Records
virtual bool Del_Records(void)
Definition: table.cpp:932
CSG_Distance_Weighting::Enable_Parameters
static bool Enable_Parameters(class CSG_Parameters &Parameters)
Definition: geo_classes.cpp:1434
SG_GRIDCELLADDR_PARM_SECTOR
#define SG_GRIDCELLADDR_PARM_SECTOR
Definition: grid.h:1101
SG_Get_Rounded
double SG_Get_Rounded(double Value, int Decimals)
Definition: mat_tools.cpp:83
CSG_Grid_System::Get_XMin
double Get_XMin(bool bCells=false) const
Definition: grid.h:244
CSG_Grid_System
Definition: grid.h:200
SG_GRIDCELLADDR_PARM_SQUARE
#define SG_GRIDCELLADDR_PARM_SQUARE
Definition: grid.h:1098
grid.h
CSG_Parameters::Add_Double
CSG_Parameter * Add_Double(const CSG_String &ParentID, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, double Value=0.0, double Minimum=0.0, bool bMinimum=false, double Maximum=0.0, bool bMaximum=false)
Definition: parameters.cpp:475
CSG_Grid_System::Create
bool Create(const CSG_Grid_System &System, int Precision=-1)
Definition: grid_system.cpp:146
SSG_Rect::xMax
double xMax
Definition: geo_tools.h:468
CSG_Grid_Cell_Addressor::Set_Square
bool Set_Square(class CSG_Parameters &Parameters)
Definition: grid_system.cpp:554
SG_GRIDCELLADDR_PARM_WEIGHTING
#define SG_GRIDCELLADDR_PARM_WEIGHTING
Definition: grid.h:1104
SG_Get_Angle_Of_Direction
double SG_Get_Angle_Of_Direction(double dx, double dy)
Definition: geo_functions.cpp:216
CSG_Grid_System::asString
const SG_Char * asString(void)
Definition: grid_system.cpp:341
CSG_Grid_Cell_Addressor::Destroy
bool Destroy(void)
Definition: grid_system.cpp:426
CSG_Grid_Cell_Addressor::Get_Count
int Get_Count(void) const
Definition: grid.h:1143
SSG_Rect::xMin
double xMin
Definition: geo_tools.h:468
SSG_Rect
Definition: geo_tools.h:467
CSG_Grid_Cell_Addressor::Enable_Parameters
static bool Enable_Parameters(class CSG_Parameters &Parameters)
Definition: grid_system.cpp:565
SG_GRIDCELLADDR_PARM_CIRCLE
#define SG_GRIDCELLADDR_PARM_CIRCLE
Definition: grid.h:1099
CSG_Grid_System::CSG_Grid_System
CSG_Grid_System(void)
Definition: grid_system.cpp:99
CSG_Grid_System::Get_Name
const SG_Char * Get_Name(bool bShort=true)
Definition: grid_system.cpp:311
CSG_Grid_System::Set_Precision
static int Set_Precision(int Decimals)
Definition: grid_system.cpp:75
CSG_Rect::Get_XRange
double Get_XRange(void) const
Definition: geo_tools.h:510
CSG_Vector
Definition: mat_tools.h:360
CSG_Rect::Get_YMin
double Get_YMin(void) const
Definition: geo_tools.h:507
CSG_Grid_System::is_Equal
bool is_Equal(const CSG_Grid_System &System) const
Definition: grid_system.cpp:393
CSG_Grid_Cell_Addressor::Add_Parameters
static bool Add_Parameters(class CSG_Parameters &Parameters, const CSG_String &Parent="", int Style=SG_GRIDCELLADDR_PARM_DEFAULT)
Definition: grid_system.cpp:444
CSG_Parameters::Set_Enabled
void Set_Enabled(bool bEnabled=true)
Definition: parameters.cpp:405
sLong
signed long long sLong
Definition: api_core.h:158
CSG_Grid_Cell_Addressor::Set_Parameters
bool Set_Parameters(class CSG_Parameters &Parameters, int Type=0)
Definition: grid_system.cpp:515
CSG_Grid_System::operator!=
bool operator!=(const CSG_Grid_System *pSystem) const
Definition: grid_system.cpp:371
SG_GRIDCELLADDR_PARM_ANNULUS
#define SG_GRIDCELLADDR_PARM_ANNULUS
Definition: grid.h:1100
CSG_Parameters::Add_Int
CSG_Parameter * Add_Int(const CSG_String &ParentID, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Value=0, int Minimum=0, bool bMinimum=false, int Maximum=0, bool bMaximum=false)
Definition: parameters.cpp:470
CSG_Grid_System::Destroy
bool Destroy(void)
Definition: grid_system.cpp:270
SG_Get_Length
double SG_Get_Length(double dx, double dy)
Definition: geo_functions.cpp:97
CSG_Grid_System::Assign
bool Assign(const CSG_Grid_System &System)
Definition: grid_system.cpp:287
M_PI_180
#define M_PI_180
Definition: mat_tools.h:102
SG_Get_Significant_Decimals
SAGA_API_DLL_EXPORT int SG_Get_Significant_Decimals(double Value, int maxDecimals=6)
Definition: api_string.cpp:1303
CSG_Grid_Cell_Addressor::Set_Radius
bool Set_Radius(double Radius, bool bSquare=false)
Definition: grid_system.cpp:683
SG_String_Tokenize
SAGA_API_DLL_EXPORT CSG_Strings SG_String_Tokenize(const CSG_String &String, const CSG_String &Delimiters=SG_DEFAULT_DELIMITERS, TSG_String_Tokenizer_Mode Mode=SG_TOKEN_DEFAULT)
Definition: api_string.cpp:1597
SG_is_Angle_Between
bool SG_is_Angle_Between(double Angle, double Angle_Min, double Angle_Max, bool bCheckRange)
Definition: geo_functions.cpp:257
CSG_Grid_Cell_Addressor::CSG_Grid_Cell_Addressor
CSG_Grid_Cell_Addressor(void)
Definition: grid_system.cpp:417
CSG_Grid_Cell_Addressor::Set_Circle
bool Set_Circle(class CSG_Parameters &Parameters)
Definition: grid_system.cpp:555
SSG_Rect::yMax
double yMax
Definition: geo_tools.h:468
CSG_Strings
Definition: api_core.h:701
CSG_Grid_System::Get_NY
int Get_NY(void) const
Definition: grid.h:239
parameters.h
CSG_String::Format
static CSG_String Format(const char *Format,...)
Definition: api_string.cpp:270
CSG_Grid_System::operator==
bool operator==(const CSG_Grid_System *pSystem) const
Definition: grid_system.cpp:366
CSG_Table::Add_Field
virtual bool Add_Field(const CSG_String &Name, TSG_Data_Type Type, int Position=-1)
Definition: table.cpp:465
CSG_Table
Definition: table.h:285
ADD_CELL
#define ADD_CELL(x, y, Distance)
SG_GRIDCELLADDR_PARM_SIZEDBL
#define SG_GRIDCELLADDR_PARM_SIZEDBL
Definition: grid.h:1102
SG_Char
#define SG_Char
Definition: api_core.h:536
shapes.h
CSG_String
Definition: api_core.h:563
CSG_Grid::asDouble
virtual double asDouble(sLong i, bool bScaled=true) const
Definition: grid.h:773
CSG_Distance_Weighting::Add_Parameters
static bool Add_Parameters(class CSG_Parameters &Parameters, const CSG_String &Parent="", bool bIDW_Offset=false)
Definition: geo_classes.cpp:1396
CSG_Rect::Get_Center
CSG_Point Get_Center(void) const
Definition: geo_tools.h:519
CSG_Grid_Cell_Addressor::Set_Sector
bool Set_Sector(class CSG_Parameters &Parameters)
Definition: grid_system.cpp:557
SSG_Point::x
double x
Definition: geo_tools.h:129
CSG_Rect::Create
bool Create(double xMin, double yMin, double xMax, double yMax)
Definition: geo_classes.cpp:698
SSG_Rect::yMin
double yMin
Definition: geo_tools.h:468
M_PI_360
#define M_PI_360
Definition: mat_tools.h:106
CSG_Rect::Get_XMin
double Get_XMin(void) const
Definition: geo_tools.h:505
CSG_Rect::Inflate
CSG_Rect & Inflate(double d, bool bPercent=true)
Definition: geo_classes.cpp:808
SSG_Point::y
double y
Definition: geo_tools.h:129
SG_GRIDCELLADDR_PARM_MAPUNIT
#define SG_GRIDCELLADDR_PARM_MAPUNIT
Definition: grid.h:1103
TABLE_INDEX_Ascending
@ TABLE_INDEX_Ascending
Definition: table.h:105
CSG_Grid_System::Get_NX
int Get_NX(void) const
Definition: grid.h:238
CSG_Grid_Cell_Addressor::Set_Annulus
bool Set_Annulus(class CSG_Parameters &Parameters)
Definition: grid_system.cpp:556
CSG_Strings::Get_Count
int Get_Count(void) const
Definition: api_core.h:714
CSG_Parameters
Definition: parameters.h:1691
CSG_Table::Add_Record
virtual CSG_Table_Record * Add_Record(CSG_Table_Record *pCopy=NULL)
Definition: table.cpp:819
CSG_Grid_System::Get_YMin
double Get_YMin(bool bCells=false) const
Definition: grid.h:248
CSG_Grid::asInt
virtual int asInt(int x, int y, bool bScaled=true) const
Definition: grid.h:765
CSG_Rect::Get_YRange
double Get_YRange(void) const
Definition: geo_tools.h:511
CSG_Grid_System::is_Valid
bool is_Valid(void) const
Definition: grid_system.cpp:305
CSG_Grid_System::~CSG_Grid_System
~CSG_Grid_System(void)
Definition: grid_system.cpp:135
CSG_Parameters::Add_Choice
CSG_Parameter * Add_Choice(const CSG_String &ParentID, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, const CSG_String &Items, int Default=0)
Definition: parameters.cpp:533
SG_DATATYPE_Double
@ SG_DATATYPE_Double
Definition: api_core.h:1006