OLD | NEW |
(Empty) | |
| 1 /* |
| 2 * ***** BEGIN GPL LICENSE BLOCK ***** |
| 3 * |
| 4 * This program is free software; you can redistribute it and/or |
| 5 * modify it under the terms of the GNU General Public License |
| 6 * as published by the Free Software Foundation; either version 2 |
| 7 * of the License, or (at your option) any later version. |
| 8 * |
| 9 * This program is distributed in the hope that it will be useful, |
| 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 12 * GNU General Public License for more details. |
| 13 * |
| 14 * You should have received a copy of the GNU General Public License |
| 15 * along with this program; if not, write to the Free Software Foundation, |
| 16 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. |
| 17 * |
| 18 * The Original Code is Copyright (C) 2010 Blender Foundation. |
| 19 * All rights reserved. |
| 20 * |
| 21 * The Original Code is: all of this file. |
| 22 * |
| 23 * Contributor(s): none yet. |
| 24 * |
| 25 * ***** END GPL LICENSE BLOCK ***** |
| 26 */ |
| 27 |
| 28 #ifndef __FREESTYLE_FUNCTIONS_1D_H__ |
| 29 #define __FREESTYLE_FUNCTIONS_1D_H__ |
| 30 |
| 31 /** \file blender/freestyle/intern/view_map/Functions1D.h |
| 32 * \ingroup freestyle |
| 33 * \brief Functions taking 1D input |
| 34 * \author Stephane Grabli |
| 35 * \author Emmanuel Turquin |
| 36 * \date 01/07/2003 |
| 37 */ |
| 38 |
| 39 #include "Functions0D.h" |
| 40 #include "Interface1D.h" |
| 41 #include "ViewMap.h" |
| 42 |
| 43 #include "../system/FreestyleConfig.h" |
| 44 #include "../system/Precision.h" |
| 45 #include "../system/TimeStamp.h" |
| 46 |
| 47 #include "../python/Director.h" |
| 48 |
| 49 // |
| 50 // UnaryFunction1D (base class for functions in 1D) |
| 51 // |
| 52 /////////////////////////////////////////////////////////// |
| 53 |
| 54 /*! Base class for Unary Functions (functors) working on Interface1D. |
| 55 * A unary function will be used by calling its operator() on an Interface1D. |
| 56 * \attention In the scripting language, there exists several prototypes depend
ing on the returned value type. |
| 57 * For example, you would inherit from a UnaryFunction1DDouble if you wish to d
efine a function that returns a double. |
| 58 * The different existing prototypes are: |
| 59 * - UnaryFunction1DVoid |
| 60 * - UnaryFunction1DUnsigned |
| 61 * - UnaryFunction1DReal |
| 62 * - UnaryFunction1DFloat |
| 63 * - UnaryFunction1DDouble |
| 64 * - UnaryFunction1DVec2f |
| 65 * - UnaryFunction1DVec3f |
| 66 */ |
| 67 template <class T> |
| 68 class /*LIB_VIEW_MAP_EXPORT*/ UnaryFunction1D |
| 69 { |
| 70 public: |
| 71 T result; |
| 72 PyObject *py_uf1D; |
| 73 |
| 74 /*! The type of the value returned by the functor. */ |
| 75 typedef T ReturnedValueType; |
| 76 |
| 77 /*! Default constructor */ |
| 78 UnaryFunction1D() |
| 79 { |
| 80 _integration = MEAN; |
| 81 } |
| 82 |
| 83 /*! Builds a UnaryFunction1D from an integration type. |
| 84 * \param iType |
| 85 * In case the result for the Interface1D would be obtained by evalua
ting a 0D function over the different |
| 86 * Interface0D of the Interface1D, \a iType tells which integration m
ethod to use. |
| 87 * The default integration method is the MEAN. |
| 88 */ |
| 89 UnaryFunction1D(IntegrationType iType) |
| 90 { |
| 91 _integration = iType; |
| 92 } |
| 93 |
| 94 /*! destructor. */ |
| 95 virtual ~UnaryFunction1D() {} |
| 96 |
| 97 /*! returns the string "UnaryFunction1D". */ |
| 98 virtual string getName() const |
| 99 { |
| 100 return "UnaryFunction1D"; |
| 101 } |
| 102 |
| 103 /*! The operator (). |
| 104 * \param inter· |
| 105 * The Interface1D on which we wish to evaluate the function. |
| 106 * \return the result of the function of type T. |
| 107 */ |
| 108 virtual int operator()(Interface1D& inter) |
| 109 { |
| 110 return Director_BPy_UnaryFunction1D___call__(this, py_uf1D, inte
r); |
| 111 } |
| 112 |
| 113 /*! Sets the integration method */ |
| 114 void setIntegrationType(IntegrationType integration) |
| 115 { |
| 116 _integration = integration; |
| 117 } |
| 118 |
| 119 /*! Returns the integration method. */ |
| 120 IntegrationType getIntegrationType() const |
| 121 { |
| 122 return _integration; |
| 123 } |
| 124 |
| 125 protected: |
| 126 IntegrationType _integration; |
| 127 }; |
| 128 |
| 129 |
| 130 class UnaryFunction1D_void |
| 131 { |
| 132 public: |
| 133 PyObject *py_uf1D; |
| 134 |
| 135 UnaryFunction1D_void() |
| 136 { |
| 137 _integration = MEAN; |
| 138 } |
| 139 |
| 140 UnaryFunction1D_void(IntegrationType iType) |
| 141 { |
| 142 _integration = iType; |
| 143 } |
| 144 |
| 145 virtual ~UnaryFunction1D_void() {} |
| 146 |
| 147 virtual string getName() const |
| 148 { |
| 149 return "UnaryFunction1D_void"; |
| 150 } |
| 151 |
| 152 int operator()(Interface1D& inter) |
| 153 { |
| 154 return Director_BPy_UnaryFunction1D___call__(this, py_uf1D, inte
r); |
| 155 } |
| 156 |
| 157 void setIntegrationType(IntegrationType integration) |
| 158 { |
| 159 _integration = integration; |
| 160 } |
| 161 |
| 162 IntegrationType getIntegrationType() const |
| 163 { |
| 164 return _integration; |
| 165 } |
| 166 |
| 167 protected: |
| 168 IntegrationType _integration; |
| 169 }; |
| 170 |
| 171 |
| 172 // |
| 173 // Functions definitions |
| 174 // |
| 175 /////////////////////////////////////////////////////////// |
| 176 |
| 177 namespace Functions1D { |
| 178 |
| 179 // GetXF1D |
| 180 /*! Returns the X 3D coordinate of an Interface1D. */ |
| 181 class LIB_VIEW_MAP_EXPORT GetXF1D : public UnaryFunction1D<real> |
| 182 { |
| 183 private: |
| 184 Functions0D::GetXF0D _func; |
| 185 |
| 186 public: |
| 187 /*! Builds the functor. |
| 188 * \param iType |
| 189 * The integration method used to compute a single value from a set o
f values. |
| 190 */ |
| 191 GetXF1D(IntegrationType iType) : UnaryFunction1D<real>(iType) {} |
| 192 |
| 193 /*! Returns the string "GetXF1D" */ |
| 194 string getName() const |
| 195 { |
| 196 return "GetXF1D"; |
| 197 } |
| 198 |
| 199 /*! the () operator. */ |
| 200 int operator()(Interface1D& inter); |
| 201 }; |
| 202 |
| 203 // GetYF1D |
| 204 /*! Returns the Y 3D coordinate of an Interface1D. */ |
| 205 class LIB_VIEW_MAP_EXPORT GetYF1D : public UnaryFunction1D<real> |
| 206 { |
| 207 private: |
| 208 Functions0D::GetYF0D _func; |
| 209 |
| 210 public: |
| 211 /*! Builds the functor. |
| 212 * \param iType |
| 213 * The integration method used to compute a single value from a set o
f values. |
| 214 */ |
| 215 GetYF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(iType) {} |
| 216 |
| 217 /*! Returns the string "GetYF1D" */ |
| 218 string getName() const |
| 219 { |
| 220 return "GetYF1D"; |
| 221 } |
| 222 |
| 223 /*! the () operator. */ |
| 224 int operator()(Interface1D& inter); |
| 225 }; |
| 226 |
| 227 // GetZF1D |
| 228 /*! Returns the Z 3D coordinate of an Interface1D. */ |
| 229 class LIB_VIEW_MAP_EXPORT GetZF1D : public UnaryFunction1D<real> |
| 230 { |
| 231 private: |
| 232 Functions0D::GetZF0D _func; |
| 233 |
| 234 public: |
| 235 /*! Builds the functor. |
| 236 * \param iType |
| 237 * The integration method used to compute a single value from a set o
f values. |
| 238 */ |
| 239 GetZF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(iType) {} |
| 240 |
| 241 /*! Returns the string "GetZF1D" */ |
| 242 string getName() const |
| 243 { |
| 244 return "GetZF1D"; |
| 245 } |
| 246 |
| 247 /*! the () operator. */ |
| 248 int operator()(Interface1D& inter); |
| 249 }; |
| 250 |
| 251 // GetProjectedXF1D |
| 252 /*! Returns the projected X 3D coordinate of an Interface1D. */ |
| 253 class LIB_VIEW_MAP_EXPORT GetProjectedXF1D : public UnaryFunction1D<real> |
| 254 { |
| 255 private: |
| 256 Functions0D::GetProjectedXF0D _func; |
| 257 |
| 258 public: |
| 259 /*! Builds the functor. |
| 260 * \param iType |
| 261 * The integration method used to compute a single value from a set o
f values. |
| 262 */ |
| 263 GetProjectedXF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(i
Type) {} |
| 264 |
| 265 /*! Returns the string "GetProjectedXF1D" */ |
| 266 string getName() const |
| 267 { |
| 268 return "GetProjectedXF1D"; |
| 269 } |
| 270 |
| 271 /*! the () operator. */ |
| 272 int operator()(Interface1D& inter); |
| 273 }; |
| 274 |
| 275 // GetProjectedYF1D |
| 276 /*! Returns the projected Y 3D coordinate of an Interface1D. */ |
| 277 class LIB_VIEW_MAP_EXPORT GetProjectedYF1D : public UnaryFunction1D<real> |
| 278 { |
| 279 private: |
| 280 Functions0D::GetProjectedYF0D _func; |
| 281 |
| 282 public: |
| 283 /*! Builds the functor. |
| 284 * \param iType |
| 285 * The integration method used to compute a single value from a set o
f values. |
| 286 */ |
| 287 GetProjectedYF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(i
Type) {} |
| 288 |
| 289 /*! Returns the string "GetProjectedYF1D" */ |
| 290 string getName() const |
| 291 { |
| 292 return "GetProjectedYF1D"; |
| 293 } |
| 294 |
| 295 /*! the () operator. */ |
| 296 int operator()(Interface1D& inter); |
| 297 }; |
| 298 |
| 299 // GetProjectedZF1D |
| 300 /*! Returns the projected Z 3D coordinate of an Interface1D. */ |
| 301 class LIB_VIEW_MAP_EXPORT GetProjectedZF1D : public UnaryFunction1D<real> |
| 302 { |
| 303 private: |
| 304 Functions0D::GetProjectedZF0D _func; |
| 305 |
| 306 public: |
| 307 /*! Builds the functor. |
| 308 * \param iType |
| 309 * The integration method used to compute a single value from a set o
f values. |
| 310 */ |
| 311 GetProjectedZF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(i
Type) {} |
| 312 |
| 313 /*! Returns the string "GetProjectedZF1D" */ |
| 314 string getName() const |
| 315 { |
| 316 return "GetProjectedZF1D"; |
| 317 } |
| 318 |
| 319 /*! the () operator. */ |
| 320 int operator()(Interface1D& inter); |
| 321 }; |
| 322 |
| 323 // Orientation2DF1D |
| 324 /*! Returns the 2D orientation as a Vec2f*/ |
| 325 class LIB_VIEW_MAP_EXPORT Orientation2DF1D : public UnaryFunction1D<Vec2f> |
| 326 { |
| 327 private: |
| 328 Functions0D::VertexOrientation2DF0D _func; |
| 329 |
| 330 public: |
| 331 /*! Builds the functor. |
| 332 * \param iType |
| 333 * The integration method used to compute a single value from a set o
f values. |
| 334 */ |
| 335 Orientation2DF1D(IntegrationType iType = MEAN) : UnaryFunction1D<Vec2f>(
iType) {} |
| 336 |
| 337 /*! Returns the string "Orientation2DF1D" */ |
| 338 string getName() const |
| 339 { |
| 340 return "Orientation2DF1D"; |
| 341 } |
| 342 |
| 343 /*! the () operator. */ |
| 344 int operator()(Interface1D& inter); |
| 345 }; |
| 346 |
| 347 // Orientation3DF1D |
| 348 /*! Returns the 3D orientation as a Vec3f. */ |
| 349 class LIB_VIEW_MAP_EXPORT Orientation3DF1D : public UnaryFunction1D<Vec3f> |
| 350 { |
| 351 private: |
| 352 Functions0D::VertexOrientation3DF0D _func; |
| 353 |
| 354 public: |
| 355 /*! Builds the functor. |
| 356 * \param iType |
| 357 * The integration method used to compute a single value from a set o
f values. |
| 358 */ |
| 359 Orientation3DF1D(IntegrationType iType = MEAN) : UnaryFunction1D<Vec3f>(
iType) {} |
| 360 |
| 361 /*! Returns the string "Orientation3DF1D" */ |
| 362 string getName() const |
| 363 { |
| 364 return "Orientation3DF1D"; |
| 365 } |
| 366 |
| 367 /*! the () operator. */ |
| 368 int operator()(Interface1D& inter); |
| 369 }; |
| 370 |
| 371 // ZDiscontinuityF1D |
| 372 /*! Returns a real giving the distance between and Interface1D and the shape tha
t lies behind (occludee). |
| 373 * This distance is evaluated in the camera space and normalized between 0 and
1. Therefore, if no oject is occluded |
| 374 * by the shape to which the Interface1D belongs to, 1 is returned. |
| 375 */ |
| 376 class LIB_VIEW_MAP_EXPORT ZDiscontinuityF1D : public UnaryFunction1D<real> |
| 377 { |
| 378 private: |
| 379 Functions0D::ZDiscontinuityF0D _func; |
| 380 |
| 381 public: |
| 382 /*! Builds the functor. |
| 383 * \param iType |
| 384 * The integration method used to compute a single value from a set o
f values. |
| 385 */ |
| 386 ZDiscontinuityF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(
iType) {} |
| 387 |
| 388 /*! Returns the string "ZDiscontinuityF1D" */ |
| 389 string getName() const |
| 390 { |
| 391 return "ZDiscontinuityF1D"; |
| 392 } |
| 393 |
| 394 /*! the () operator. */ |
| 395 int operator()(Interface1D& inter); |
| 396 }; |
| 397 |
| 398 // QuantitativeInvisibilityF1D |
| 399 /*! Returns the Quantitative Invisibility of an Interface1D element. |
| 400 * If the Interface1D is a ViewEdge, then there is no ambiguity concerning the
result. But, if the Interface1D |
| 401 * results of a chaining (chain, stroke), then it might be made of several 1D e
lements of different |
| 402 * Quantitative Invisibilities. |
| 403 */ |
| 404 class LIB_VIEW_MAP_EXPORT QuantitativeInvisibilityF1D : public UnaryFunction1D<u
nsigned> |
| 405 { |
| 406 private: |
| 407 Functions0D::QuantitativeInvisibilityF0D _func; |
| 408 |
| 409 public: |
| 410 /*! Builds the functor. |
| 411 * \param iType |
| 412 * The integration method used to compute a single value from a set o
f values. |
| 413 */ |
| 414 QuantitativeInvisibilityF1D(IntegrationType iType = MEAN) : UnaryFunctio
n1D<unsigned int>(iType) {} |
| 415 |
| 416 /*! Returns the string "QuantitativeInvisibilityF1D" */ |
| 417 string getName() const |
| 418 { |
| 419 return "QuantitativeInvisibilityF1D"; |
| 420 } |
| 421 |
| 422 /*! the () operator. */ |
| 423 int operator()(Interface1D& inter); |
| 424 }; |
| 425 |
| 426 // CurveNatureF1D |
| 427 /*! Returns the nature of the Interface1D (silhouette, ridge, crease...). |
| 428 * Except if the Interface1D is a ViewEdge, this result might be ambiguous. |
| 429 * Indeed, the Interface1D might result from the gathering of several 1D elemen
ts, each one being of a different |
| 430 * nature. An integration method, such as the MEAN, might give, in this case, i
rrelevant results. |
| 431 */ |
| 432 class LIB_VIEW_MAP_EXPORT CurveNatureF1D : public UnaryFunction1D<Nature::EdgeNa
ture> |
| 433 { |
| 434 private: |
| 435 Functions0D::CurveNatureF0D _func; |
| 436 |
| 437 public: |
| 438 /*! Builds the functor. |
| 439 * \param iType |
| 440 * The integration method used to compute a single value from a set o
f values. |
| 441 */ |
| 442 CurveNatureF1D(IntegrationType iType = MEAN) : UnaryFunction1D<Nature::E
dgeNature>(iType) {} |
| 443 |
| 444 /*! Returns the string "CurveNatureF1D" */ |
| 445 string getName() const |
| 446 { |
| 447 return "CurveNatureF1D"; |
| 448 } |
| 449 |
| 450 /*! the () operator. */ |
| 451 int operator()(Interface1D& inter); |
| 452 }; |
| 453 |
| 454 // TimeStampF1D |
| 455 /*! Returns the time stamp of the Interface1D. */ |
| 456 class LIB_VIEW_MAP_EXPORT TimeStampF1D : public UnaryFunction1D_void |
| 457 { |
| 458 public: |
| 459 /*! Returns the string "TimeStampF1D" */ |
| 460 string getName() const |
| 461 { |
| 462 return "TimeStampF1D"; |
| 463 } |
| 464 |
| 465 /*! the () operator. */ |
| 466 int operator()(Interface1D& inter); |
| 467 }; |
| 468 |
| 469 // IncrementChainingTimeStampF1D |
| 470 /*! Increments the chaining time stamp of the Interface1D. */ |
| 471 class LIB_VIEW_MAP_EXPORT IncrementChainingTimeStampF1D : public UnaryFunction1D
_void |
| 472 { |
| 473 public: |
| 474 /*! Returns the string "IncrementChainingTimeStampF1D" */ |
| 475 string getName() const |
| 476 { |
| 477 return "IncrementChainingTimeStampF1D"; |
| 478 } |
| 479 |
| 480 /*! the () operator. */ |
| 481 int operator()(Interface1D& inter); |
| 482 }; |
| 483 |
| 484 // ChainingTimeStampF1D |
| 485 /*! Sets the chaining time stamp of the Interface1D. */ |
| 486 class LIB_VIEW_MAP_EXPORT ChainingTimeStampF1D : public UnaryFunction1D_void |
| 487 { |
| 488 public: |
| 489 /*! Returns the string "ChainingTimeStampF1D" */ |
| 490 string getName() const |
| 491 { |
| 492 return "ChainingTimeStampF1D"; |
| 493 } |
| 494 |
| 495 /*! the () operator. */ |
| 496 int operator()(Interface1D& inter); |
| 497 }; |
| 498 |
| 499 |
| 500 // Curvature2DAngleF1D |
| 501 /*! Returns the 2D curvature as an angle for an Interface1D. */ |
| 502 class LIB_VIEW_MAP_EXPORT Curvature2DAngleF1D : public UnaryFunction1D<real> |
| 503 { |
| 504 public: |
| 505 /*! Builds the functor. |
| 506 * \param iType |
| 507 * The integration method used to compute a single value from a set o
f values. |
| 508 */ |
| 509 Curvature2DAngleF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real
>(iType) {} |
| 510 |
| 511 /*! Returns the string "Curvature2DAngleF1D" */ |
| 512 string getName() const |
| 513 { |
| 514 return "Curvature2DAngleF1D"; |
| 515 } |
| 516 |
| 517 /*! the () operator.*/ |
| 518 int operator()(Interface1D& inter) |
| 519 { |
| 520 result = integrate(_fun, inter.verticesBegin(), inter.verticesEn
d(), _integration); |
| 521 return 0; |
| 522 } |
| 523 |
| 524 private: |
| 525 Functions0D::Curvature2DAngleF0D _fun; |
| 526 }; |
| 527 |
| 528 // Normal2DF1D |
| 529 /*! Returns the 2D normal for an interface 1D. */ |
| 530 class LIB_VIEW_MAP_EXPORT Normal2DF1D : public UnaryFunction1D<Vec2f> |
| 531 { |
| 532 public: |
| 533 /*! Builds the functor. |
| 534 * \param iType |
| 535 * The integration method used to compute a single value from a set o
f values. |
| 536 */ |
| 537 Normal2DF1D(IntegrationType iType = MEAN) : UnaryFunction1D<Vec2f>(iType
) {} |
| 538 |
| 539 /*! Returns the string "Normal2DF1D" */ |
| 540 string getName() const |
| 541 { |
| 542 return "Normal2DF1D"; |
| 543 } |
| 544 |
| 545 /*! the () operator.*/ |
| 546 int operator()(Interface1D& inter) |
| 547 { |
| 548 result = integrate(_fun, inter.verticesBegin(), inter.verticesEn
d(), _integration); |
| 549 return 0; |
| 550 } |
| 551 |
| 552 private: |
| 553 Functions0D::Normal2DF0D _fun; |
| 554 }; |
| 555 |
| 556 // GetShapeF1D |
| 557 /*! Returns list of shapes covered by this Interface1D. */ |
| 558 class LIB_VIEW_MAP_EXPORT GetShapeF1D : public UnaryFunction1D<std::vector<ViewS
hape*> > |
| 559 { |
| 560 public: |
| 561 /*! Builds the functor. */ |
| 562 GetShapeF1D() : UnaryFunction1D<std::vector<ViewShape*> >() {} |
| 563 |
| 564 /*! Returns the string "GetShapeF1D" */ |
| 565 string getName() const |
| 566 { |
| 567 return "GetShapeF1D"; |
| 568 } |
| 569 |
| 570 /*! the () operator. */ |
| 571 int operator()(Interface1D& inter); |
| 572 }; |
| 573 |
| 574 // GetOccludersF1D |
| 575 /*! Returns list of occluding shapes covered by this Interface1D. */ |
| 576 class LIB_VIEW_MAP_EXPORT GetOccludersF1D : public UnaryFunction1D<std::vector<V
iewShape*> > |
| 577 { |
| 578 public: |
| 579 /*! Builds the functor. */ |
| 580 GetOccludersF1D() : UnaryFunction1D<std::vector<ViewShape*> >() {} |
| 581 |
| 582 /*! Returns the string "GetOccludersF1D" */ |
| 583 string getName() const |
| 584 { |
| 585 return "GetOccludersF1D"; |
| 586 } |
| 587 |
| 588 /*! the () operator. */ |
| 589 int operator()(Interface1D& inter); |
| 590 }; |
| 591 |
| 592 // GetOccludeeF1D |
| 593 /*! Returns list of occluded shapes covered by this Interface1D. */ |
| 594 class LIB_VIEW_MAP_EXPORT GetOccludeeF1D : public UnaryFunction1D<std::vector<Vi
ewShape*> > |
| 595 { |
| 596 public: |
| 597 /*! Builds the functor. */ |
| 598 GetOccludeeF1D() : UnaryFunction1D<std::vector<ViewShape*> >() {} |
| 599 |
| 600 /*! Returns the string "GetOccludeeF1D" */ |
| 601 string getName() const |
| 602 { |
| 603 return "GetOccludeeF1D"; |
| 604 } |
| 605 |
| 606 /*! the () operator. */ |
| 607 int operator()(Interface1D& inter); |
| 608 }; |
| 609 |
| 610 // internal |
| 611 //////////// |
| 612 |
| 613 // getOccludeeF1D |
| 614 LIB_VIEW_MAP_EXPORT |
| 615 void getOccludeeF1D(Interface1D& inter, set<ViewShape*>& oShapes); |
| 616 |
| 617 // getOccludersF1D |
| 618 LIB_VIEW_MAP_EXPORT |
| 619 void getOccludersF1D(Interface1D& inter, set<ViewShape*>& oShapes); |
| 620 |
| 621 // getShapeF1D |
| 622 LIB_VIEW_MAP_EXPORT |
| 623 void getShapeF1D(Interface1D& inter, set<ViewShape*>& oShapes); |
| 624 |
| 625 } // end of namespace Functions1D |
| 626 |
| 627 #endif // __FREESTYLE_FUNCTIONS_1D_H__ |
OLD | NEW |