sprk_exchange.h
1 // Copyright (c) Tech Soft 3D, Inc.
2 //
3 // The information contained herein is confidential and proprietary to Tech Soft 3D, Inc.,
4 // and considered a trade secret as defined under civil and criminal statutes.
5 // Tech Soft 3D, Inc. shall pursue its civil and criminal remedies in the event of
6 // unauthorized use or misappropriation of its trade secrets. Use of this information
7 // by anyone other than authorized employees of Tech Soft 3D, Inc. is granted only under
8 // a written non-disclosure agreement, expressly prescribing the scope and manner of such use.
9 
10 #ifndef SPRK_EXCHANGE_H
11 #define SPRK_EXCHANGE_H
12 
13 #include "sprk.h"
14 
15 typedef void A3DEntity;
16 typedef void A3DAsmModelFile;
17 typedef void A3DRWParamsPrcReadHelper;
18 
19 #ifdef _MSC_VER
20 #ifndef STATIC_APP
21 # ifdef SPRK_EXCHANGE
22 # define EXCHANGE_API __declspec (dllexport)
23 # else
24 # define EXCHANGE_API __declspec (dllimport)
25 # endif
26 #endif
27 #else
28 # include <stddef.h>
29 # if defined(LINUX_SYSTEM) && defined(SPRK_EXCHANGE)
30 # ifndef STATIC_APP
31 # define EXCHANGE_API __attribute__ ((visibility ("default")))
32 # endif
33 # endif
34 #endif
35 
36 #ifndef EXCHANGE_API
37 # define EXCHANGE_API
38 #endif
39 
40 namespace HPS
41 {
42 
44 class EXCHANGE_API Exchange
45 {
46 public:
47 
48  class Component;
49  class Configuration;
50  class Sheet;
52  class TranslationNotifier;
55  class ReloadNotifier;
56 
57  typedef std::vector<Configuration, HPS::Allocator<Configuration> > ConfigurationArray;
58  typedef std::vector<Sheet, HPS::Allocator<Sheet> > SheetArray;
59  typedef HPS::IntArray ParasolidEntityArray;
60 
63  enum class Units
64  {
65  Unknown,
66  Point,
67  Inch,
68  Millimeter,
69  Centimeter,
70  Pica,
71  Foot,
72  Yard,
73  Meter,
74  Kilometer,
75  Mile
76  };
77 
80  enum class UnloadMode
81  {
84  ExchangeAndVisualization,
85 
90  ExchangeOnly,
91  };
92 
95  enum class LoadStatus
96  {
98  Unknown,
100  Loaded,
102  VisualizationOnly,
104  PartiallyLoaded,
106  NotLoaded
107  };
108 
111  class EXCHANGE_API Component : public HPS::Component
112  {
113  public:
115  Component();
116 
120  Component(HPS::Component const & in_that);
121 
124  Component(Exchange::Component const & in_that);
125 
128  Component(Exchange::Component && in_that);
129 
130  virtual ~Component();
131 
132  HPS::Type ObjectType() const { return HPS::Type::ExchangeComponent; }
133 
134 #if !defined(_MSC_VER) || _MSC_VER >= 1900
135  Component & operator=(Component const & in_that) = default;
136 #endif
137 
141  Component & operator=(Exchange::Component && in_that);
142 
143 
146  A3DEntity * GetExchangeEntity() const;
147 
148 
154  void Tessellate(TessellationOptionsKit const & in_options);
155 
162  TranslationNotifier Translate(Units in_units, TranslationOptionsKit const & in_translation_options);
163 
170  ReloadNotifier Reload(TessellationOptionsKit const & in_tessellation_options = TessellationOptionsKit(), TranslationOptionsKit const & in_translation_options = TranslationOptionsKit());
171  };
172 
173  class EXCHANGE_API ProductOccurrence : public Exchange::Component
174  {
175  public:
178 
182  ProductOccurrence(HPS::Component const & in_that);
183 
187  ProductOccurrence(Component const & in_that);
188 
191  ProductOccurrence(ProductOccurrence const & in_sheet);
192 
197 
201  ProductOccurrence & operator=(ProductOccurrence && in_that);
202 
203  virtual ~ProductOccurrence();
204 
205  HPS::Type ObjectType() const { return HPS::Type::ExchangeProductOccurrence; }
206 
210  bool Equals(ProductOccurrence const & in_kit) const;
211 
215  bool operator==(ProductOccurrence const & in_kit) const;
216 
220  bool operator!=(ProductOccurrence const & in_kit) const;
221 
227  void Unload(UnloadMode in_mode = UnloadMode::ExchangeAndVisualization);
228 
234  LoadStatus GetLoadStatus() const;
235  };
236 
238  class EXCHANGE_API Sheet : public Exchange::Component
239  {
240  public:
242  Sheet();
243 
247  Sheet(HPS::Component const & in_that);
248 
252  Sheet(Component const & in_that);
253 
256  Sheet(Sheet const & in_sheet);
257 
261  Sheet(Sheet && in_that);
262 
266  Sheet & operator=(Sheet && in_that);
267 
268  virtual ~Sheet();
269 
270  HPS::Type ObjectType() const { return HPS::Type::ExchangeSheet; }
271 
275  bool Equals(Sheet const & in_kit) const;
276 
277 #if !defined(_MSC_VER) || _MSC_VER >= 1900
278  Sheet & operator=(Sheet const & in_that) = default;
279 #endif
280 
284  bool operator==(Sheet const & in_kit) const;
285 
289  bool operator!=(Sheet const & in_kit) const;
290 
291  /* Activates this sheet */
292  HPS::View Activate();
293  };
294 
297  class EXCHANGE_API CADModel : public HPS::CADModel
298  {
299  public:
301  CADModel();
302 
306  CADModel(Component const & in_that);
307 
311  CADModel(HPS::CADModel const & in_that);
312 
315  CADModel(Exchange::CADModel const & in_that);
316 
319  CADModel(Exchange::CADModel && in_that);
320 
321  virtual ~CADModel();
322 
323  HPS::Type ObjectType() const { return HPS::Type::ExchangeCADModel; }
324 
325 #if !defined(_MSC_VER) || _MSC_VER >= 1900
326  CADModel & operator=(Exchange::CADModel const & in_that) = default;
327 #endif
328 
332  CADModel & operator=(Exchange::CADModel && in_that);
333 
334 
337  A3DEntity * GetExchangeEntity() const;
338 
342  HPS::Component GetComponentFromEntity(A3DEntity * in_entity) const;
343 
349  bool GetEntityOwnership() const;
350 
351 
355  UTF8Array GetCurrentConfiguration() const;
356 
360  ConfigurationArray GetConfigurations() const;
361 
362  /* Gets a list of sheets for this CADModel (if any). Only formats which support the concept of sheets can return a non-empty array.
363  * \return The list of sheets for this CADModel */
364  SheetArray GetSheets() const;
365 
371  TranslationNotifier Translate(TranslationOptionsKit const & in_translation_options);
372 
377  ReloadNotifier Reload(TessellationOptionsKit const & in_options = TessellationOptionsKit(), TranslationOptionsKit const & in_translation_options = TranslationOptionsKit());
378 
384  void ShowAllPMI(Canvas & in_canvas, size_t in_layer = 0);
385 
391  void SetAllPMIInFront(bool in_enable, Canvas & in_canvas, size_t in_layer = 0);
392 
398  void HideAllPMI(Canvas & in_canvas, size_t in_layer = 0);
399 
404  void Tessellate(TessellationOptionsKit const & in_options);
405  };
406 
409  class EXCHANGE_API Capture : public HPS::Capture
410  {
411  public:
413  Capture();
414 
418  Capture(Component const & in_that);
419 
423  Capture(HPS::Capture const & in_that);
424 
427  Capture(Exchange::Capture const & in_that);
428 
431  Capture(Exchange::Capture && in_that);
432 
433  virtual ~Capture();
434 
435  HPS::Type ObjectType() const { return HPS::Type::ExchangeCapture; }
436 
437 #if !defined(_MSC_VER) || _MSC_VER >= 1900
438  Capture & operator=(Exchange::Capture const & in_that) = default;
439 #endif
440 
444  Capture & operator=(Exchange::Capture && in_that);
445 
446 
449  A3DEntity * GetExchangeEntity() const;
450  };
451 
454  class EXCHANGE_API Filter : public HPS::Filter
455  {
456  public:
458  Filter();
459 
463  Filter(Component const & in_that);
464 
468  Filter(HPS::Filter const & in_that);
469 
472  Filter(Exchange::Filter const & in_that);
473 
476  Filter(Exchange::Filter && in_that);
477 
478  virtual ~Filter();
479 
480  HPS::Type ObjectType() const { return HPS::Type::ExchangeFilter; }
481 
482 #if !defined(_MSC_VER) || _MSC_VER >= 1900
483  Filter & operator=(Exchange::Filter const & in_that) = default;
484 #endif
485 
489  Filter & operator=(Exchange::Filter && in_that);
490 
491 
494  A3DEntity * GetExchangeEntity() const;
495  };
496 
498  class EXCHANGE_API Factory : public Sprocket
499  {
500  public:
505  static Component CreateComponent(HPS::Component const & in_owner, HPS::Component::ComponentType in_type, A3DEntity * in_entity = nullptr);
506 
512  static CADModel CreateCADModel(Model const & in_model = HPS::Factory::CreateModel(), A3DAsmModelFile * in_entity = nullptr, bool in_owns_entity = false);
513 
517  static Filter CreateFilter(HPS::Component const & in_owner, A3DEntity * in_entity = nullptr);
518 
525  static Capture CreateCapture(HPS::Component const & in_owner, A3DEntity * in_entity = nullptr, bool in_is_default = false);
526 
530  static Sheet CreateSheet(HPS::Component const & in_owner, A3DEntity * in_entity = nullptr);
531 
532  private:
534  Factory();
535  };
536 
538  class EXCHANGE_API ImportNotifier : public IONotifier
539  {
540  public:
542  ImportNotifier();
543 
546  ImportNotifier(ImportNotifier const & in_that);
547 
552  ImportNotifier(IONotifier const & in_that);
553 
557  ImportNotifier(ImportNotifier && in_that);
558 
562  ImportNotifier & operator=(ImportNotifier && in_that);
563 
564  virtual ~ImportNotifier();
565 
566  HPS::Type ObjectType() const { return HPS::Type::ExchangeImportNotifier; };
567 
571  ImportNotifier & operator=(ImportNotifier const & in_that);
572 
575  void Assign(ImportNotifier const & in_that);
576 
579  Exchange::CADModel GetCADModel() const;
580 
586  A3DRWParamsPrcReadHelper * GetPRCReadHelper() const;
587 
590  Time GetImportTime() const;
591 
594  Time GetParseTime() const;
595  };
596 
598  class EXCHANGE_API TranslationNotifier : public IONotifier
599  {
600  public:
603 
606  TranslationNotifier(TranslationNotifier const & in_that);
607 
612  TranslationNotifier(IONotifier const & in_that);
613 
618 
622  TranslationNotifier & operator=(TranslationNotifier && in_that);
623 
624  virtual ~TranslationNotifier();
625 
626  HPS::Type ObjectType() const { return HPS::Type::ExchangeTranslationNotifier; };
627 
631  TranslationNotifier & operator=(TranslationNotifier const & in_that);
632 
635  void Assign(TranslationNotifier const & in_that);
636 
639  Exchange::ParasolidEntityArray GetParasolidParts() const;
640 
643  HPS::Time GetImportTime() const;
644 
647  HPS::Time GetTranslationTime() const;
648  };
649 
651  class EXCHANGE_API ExportNotifier : public IONotifier
652  {
653  public:
655  ExportNotifier();
656 
659  ExportNotifier(ExportNotifier const & in_that);
660 
665  ExportNotifier(IONotifier const & in_that);
666 
670  ExportNotifier(ExportNotifier && in_that);
671 
675  ExportNotifier & operator=(ExportNotifier && in_that);
676 
677  virtual ~ExportNotifier();
678 
679  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportNotifier; };
680 
684  ExportNotifier & operator=(ExportNotifier const & in_that);
685 
688  void Assign(ExportNotifier const & in_that);
689 
693  A3DAsmModelFile * GetModelFile() const;
694  };
695 
697  class EXCHANGE_API ReloadNotifier : public IONotifier
698  {
699  public:
701  ReloadNotifier();
702 
705  ReloadNotifier(ReloadNotifier const & in_that);
706 
711  ReloadNotifier(IONotifier const & in_that);
712 
716  ReloadNotifier(ReloadNotifier && in_that);
717 
721  ReloadNotifier & operator=(ReloadNotifier && in_that);
722 
723  virtual ~ReloadNotifier();
724 
725  HPS::Type ObjectType() const { return HPS::Type::ExchangeReloadNotifier; };
726 
730  ReloadNotifier & operator=(ReloadNotifier const & in_that);
731 
734  void Assign(ReloadNotifier const & in_that);
735  };
736 
737 
738  class ImportOptionsKit;
739  class ModelFileImportOptionsKit;
740  class Export3MFOptionsKit;
741  class ExportACISOptionsKit;
742  class ExportIGESOptionsKit;
743  class ExportJTOptionsKit;
744  class ExportPRCOptionsKit;
745  class ExportSTEPOptionsKit;
746  class ExportSTLOptionsKit;
747  class ExportU3DOptionsKit;
748  class ExportXMLOptionsKit;
749 
750 
753  enum class BRepMode
754  {
757  TessellationOnly,
760  BRepOnly,
763  BRepAndTessellation,
764  };
765 
768  enum class ImportMode
769  {
772  Complete,
775  Incremental,
776  };
777 
780  enum class SurfaceType
781  {
782  Blend01,
783  Blend02,
784  Blend03,
785  Blend04,
786  NURBS,
787  Cone,
788  Cylinder,
789  Offset,
790  Pipe,
791  Plane,
792  Ruled,
793  Sphere,
794  Revolution,
795  Extrusion,
796  FromCurve,
797  Torus,
798  Transform,
799  };
800 
803  enum class CurveType
804  {
805  Blend,
806  NURBS,
807  Circle,
808  Composite,
809  CurveOnSurface,
810  Ellipse,
811  Equation,
812  Helix,
813  Hyperbola,
814  Intersection,
815  Line,
816  Offset,
817  Parabola,
818  Polyline,
819  Transform,
820  };
821 
822  typedef std::vector<SurfaceType, HPS::Allocator<SurfaceType> > SurfaceTypeArray;
823  typedef std::vector<CurveType, HPS::Allocator<CurveType> > CurveTypeArray;
824 
828  {
829  PMIOnly,
830  ModelAndPMI
831  };
832 
834  class EXCHANGE_API Tessellation
835  {
836  public:
839  enum class Type
840  {
841  Standard,
842  Custom
843  };
844 
845 
848  enum class Level
849  {
850  ExtraLow,
851  Low,
852  Medium,
853  High,
854  ExtraHigh,
855  };
856 
858  class EXCHANGE_API Chord
859  {
860  public:
863  enum class Limit
864  {
867  Ratio,
870  Height
871  };
872 
873  private:
875  Chord();
876  };
877 
880  enum class Accuracy
881  {
884  Standard,
887  Accurate
888  };
889 
890  private:
892  Tessellation();
893  };
894 
896  class EXCHANGE_API JT
897  {
898  public:
901  enum class Content
902  {
903  Geometry,
904  Tessellation,
905  GeometryAndTessellation
906  };
907 
910  enum class TessellationLevel
911  {
912  Low,
913  Medium,
914  High,
915  };
916 
919  enum class Version
920  {
921  JT81,
922  JT95,
923  };
924 
925  private:
927  JT();
928  };
929 
931  class EXCHANGE_API STEP
932  {
933  public:
936  enum class Field
937  {
938  ProductName,
939  NextAssemblyUsageOccurrenceID,
940  NextAssemblyUsageOccurrenceName,
941  NextAssemblyUsageOccurrenceDescription
942  };
943 
946  enum class Format
947  {
948  AP203,
949  AP214,
950  AP242,
951  };
952 
953  private:
955  STEP();
956  };
957 
959  class EXCHANGE_API PRC
960  {
961  public:
964  enum class BRepCompression
965  {
966  None,
967  Low,
968  Medium,
969  High
970  };
971 
972  private:
974  PRC();
975  };
976 
978  class EXCHANGE_API ProE
979  {
980  public:
983  enum class SessionColor
984  {
986  LastCreoVersion,
988  ExchangeDefault,
991  UserDefined
992  };
993 
996  enum class FamilyTable
997  {
999  BRepOnly,
1001  BRepOrTessellation,
1003  BRepOrTessellationOrGeneric
1004  };
1005 
1009  {
1011  On,
1013  Off,
1015  AsDatum,
1016  };
1017 
1018  private:
1020  ProE();
1021  };
1022 
1024  class EXCHANGE_API U3D
1025  {
1026  public:
1029  enum class Version
1030  {
1031  ECMA1,
1032  ECMA3
1033  };
1034 
1035  private:
1037  U3D();
1038  };
1039 
1041  class EXCHANGE_API Configuration : public HPS::Sprocket
1042  {
1043  public:
1045  Configuration();
1046 
1049  Configuration(char const * in_name);
1050 
1055  Configuration(char const * in_name, size_t in_count, Configuration const in_subconfigurations[]);
1056 
1060  Configuration(char const * in_name, ConfigurationArray const & in_subconfigurations);
1061 
1064  Configuration(Configuration const & in_configuration);
1065 
1069  Configuration(Configuration && in_that);
1070 
1074  Configuration & operator=(Configuration && in_that);
1075 
1076  virtual ~Configuration();
1077 
1078  HPS::Type ObjectType() const { return HPS::Type::ExchangeConfiguration; }
1079 
1080 
1083  void Set(Configuration const & in_kit);
1084 
1087  void Show(Configuration & out_kit) const;
1088 
1092  Configuration & operator=(Configuration const & in_kit);
1093 
1096  bool Empty() const;
1097 
1101  bool Equals(Configuration const & in_kit) const;
1102 
1106  bool operator==(Configuration const & in_kit) const;
1107 
1111  bool operator!=(Configuration const & in_kit) const;
1112 
1113 
1116  HPS::UTF8 GetName() const;
1117 
1120  ConfigurationArray GetSubconfigurations() const;
1121  };
1122 
1124  class EXCHANGE_API File
1125  {
1126  public:
1129  enum class Format
1130  {
1131  Unsupported,
1132  ACIS,
1133  CADDS,
1134  CATIAV4,
1135  CATIAV5,
1136  CGR,
1137  COLLADA,
1138  CreoProE,
1139  IDEAS,
1140  IFC,
1141  IGES,
1142  Inventor,
1143  JT,
1144  KeyholeMarkupLanguage,
1145  LatticeXVL,
1146  OneSpaceDesigner,
1147  Parasolid,
1148  PDF,
1149  PRC,
1150  Rhino,
1151  NXUnigraphics,
1152  SolidEdge,
1153  SolidWorks,
1154  STEP,
1155  StereoLithography,
1156  ThreeDStudioMax,
1157  ThreeDXML,
1158  Universal3D,
1159  VDAFS,
1160  VRML,
1161  WavefrontObject,
1162  };
1163 
1165  static Format GetFormat(char const * in_file_name);
1166 
1170  static ConfigurationArray GetConfigurations(char const * in_file_name);
1171 
1183  static void GetInformation(const char * in_file_name, Format & out_format, UTF8 & out_model_name, UTF8 & out_version, UTF8 & out_author, UTF8 & out_organization, UTF8 & out_time_stamp);
1184 
1190  static HPS::ImageKit GetThumbnailImage(const char * in_file_name);
1191 
1198  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
1199 
1206  static ImportNotifier Import(A3DAsmModelFile const * in_model_file, ModelFileImportOptionsKit const & in_options);
1207 
1215  static ImportNotifier Import(size_t in_byte_count, byte const in_prc_data[], ModelFileImportOptionsKit const & in_options);
1216 
1223  static ImportNotifier Import(ByteArray const & in_prc_data, ModelFileImportOptionsKit const & in_options);
1224 
1225 
1232  static TranslationNotifier Translate(char const * in_file_name, ImportOptionsKit const & in_options, TranslationOptionsKit const & in_translation_options);
1233 
1238  static ExportNotifier Export3MF(CADModel const & in_cad_model, char const * in_file_name, Export3MFOptionsKit const & in_options);
1239 
1245  static ExportNotifier Export3MF(KeyPathArray const & in_source, char const * in_file_name, Export3MFOptionsKit const & in_options);
1246 
1253  static ExportNotifier Export3MF(size_t in_count, KeyPath const in_source[], char const * in_file_name, Export3MFOptionsKit const & in_options);
1254 
1260  static ExportNotifier Export3MF(KeyPath in_source, char const * in_file_name, Export3MFOptionsKit const & in_options);
1261 
1266  static void ExportACIS(CADModel const & in_cad_model, char const * in_file_name, ExportACISOptionsKit const & in_options);
1267 
1272  static void ExportIGES(CADModel const & in_cad_model, char const * in_file_name, ExportIGESOptionsKit const & in_options);
1273 
1278  static void ExportJT(CADModel const & in_cad_model, char const * in_file_name, ExportJTOptionsKit const & in_options);
1279 
1284  static void ExportParasolid(CADModel const & in_cad_model, char const * in_file_name, ExportParasolidOptionsKit const & in_options);
1285 
1291  static ExportNotifier ExportPRC(CADModel const & in_cad_model, char const * in_file_name, ExportPRCOptionsKit const & in_options);
1292 
1298  static ExportNotifier ExportPRC(KeyPathArray const & in_source, char const * in_file_name, bool in_compress_tessellation = false);
1299 
1306  static ExportNotifier ExportPRC(size_t in_count, KeyPath const in_source [], char const * in_file_name, bool in_compress_tessellation = false);
1307 
1314  static ExportNotifier ExportPRC(KeyPath const & in_source, char const * in_file_name, bool in_compress_tessellation = false);
1315 
1319  static ExportNotifier ExportPRC(KeyPathArray const & in_source);
1320 
1325  static ExportNotifier ExportPRC(size_t in_count, KeyPath const in_source []);
1326 
1330  static ExportNotifier ExportPRC(KeyPath const & in_source);
1331 
1336  static void ExportSTEP(CADModel const & in_cad_model, char const * in_file_name, ExportSTEPOptionsKit const & in_options);
1337 
1342  static void ExportSTL(CADModel const & in_cad_model, char const * in_file_name, ExportSTLOptionsKit const & in_options);
1343 
1348  static void ExportU3D(CADModel const & in_cad_model, char const * in_file_name, ExportU3DOptionsKit const & in_options);
1349 
1353  static void ExportVRML(CADModel const & in_cad_model, char const * in_file_name);
1354 
1359  static void ExportXML(CADModel const & in_cad_model, char const * in_file_name, ExportXMLOptionsKit const & in_options);
1360 
1361  private:
1363  File();
1364  };
1365 
1367  class EXCHANGE_API NURBSConversionOptionsKit : public SprocketKit
1368  {
1369  public:
1372 
1376 
1381 
1385  NURBSConversionOptionsKit & operator=(NURBSConversionOptionsKit && in_that);
1386 
1387  virtual ~NURBSConversionOptionsKit();
1388 
1389  HPS::Type ObjectType() const { return HPS::Type::ExchangeNURBSConversionOptionsKit; }
1390 
1393  void Set(NURBSConversionOptionsKit const & in_kit);
1394 
1397  void Show(NURBSConversionOptionsKit & out_kit) const;
1398 
1402  NURBSConversionOptionsKit & operator=(NURBSConversionOptionsKit const & in_kit);
1403 
1406  bool Empty() const;
1407 
1411  bool Equals(NURBSConversionOptionsKit const & in_kit) const;
1412 
1416  bool operator==(NURBSConversionOptionsKit const & in_kit) const;
1417 
1421  bool operator!=(NURBSConversionOptionsKit const & in_kit) const;
1422 
1426  static NURBSConversionOptionsKit GetDefault();
1427 
1432  NURBSConversionOptionsKit & SetCrossSeamCurveReplacement(bool in_state);
1433 
1438  NURBSConversionOptionsKit & Set3DCurvesComputation(bool in_state);
1439 
1444  NURBSConversionOptionsKit & SetUVCurvesComputation(bool in_state, bool in_allow_cross_seam_curves);
1445 
1450  NURBSConversionOptionsKit & SetClosedSurfaceSplitting(bool in_state);
1451 
1456  NURBSConversionOptionsKit & SetPeriodicSurfaceSplitting(bool in_state);
1457 
1462  NURBSConversionOptionsKit & SetParameterization(bool in_state);
1463 
1468  NURBSConversionOptionsKit & SetTolerance(double in_tolerance);
1469 
1475  NURBSConversionOptionsKit & SetAllowedSurfaces(SurfaceTypeArray const & in_allowed_surfaces);
1476 
1483  NURBSConversionOptionsKit & SetAllowedSurfaces(size_t in_count, SurfaceType const in_allowed_surfaces []);
1484 
1490  NURBSConversionOptionsKit & SetAllowedCurves(CurveTypeArray const & in_allowed_curves);
1491 
1498  NURBSConversionOptionsKit & SetAllowedCurves(size_t in_count, CurveType const in_allowed_curves []);
1499 
1500 
1503  NURBSConversionOptionsKit & UnsetCrossSeamCurveReplacement();
1504 
1507  NURBSConversionOptionsKit & Unset3DCurvesComputation();
1508 
1511  NURBSConversionOptionsKit & UnsetUVCurvesComputation();
1512 
1515  NURBSConversionOptionsKit & UnsetClosedSurfaceSplitting();
1516 
1519  NURBSConversionOptionsKit & UnsetPeriodicSurfaceSplitting();
1520 
1523  NURBSConversionOptionsKit & UnsetParameterization();
1524 
1527  NURBSConversionOptionsKit & UnsetTolerance();
1528 
1531  NURBSConversionOptionsKit & UnsetAllowedSurfaces();
1532 
1535  NURBSConversionOptionsKit & UnsetAllowedCurves();
1536 
1539  NURBSConversionOptionsKit & UnsetEverything();
1540 
1541 
1542 
1546  bool ShowCrossSeamCurveReplacement(bool & out_state) const;
1547 
1551  bool Show3DCurvesComputation(bool & out_state) const;
1552 
1557  bool ShowUVCurvesComputation(bool & out_state, bool & out_allow_cross_seam_curves) const;
1558 
1562  bool ShowClosedSurfaceSplitting(bool & out_state) const;
1563 
1567  bool ShowPeriodicSurfaceSplitting(bool & out_state) const;
1568 
1572  bool ShowParameterization(bool & out_state) const;
1573 
1577  bool ShowTolerance(double & out_tolerance) const;
1578 
1582  bool ShowAllowedSurfaces(SurfaceTypeArray & out_allowed_surfaces) const;
1583 
1587  bool ShowAllowedCurves(CurveTypeArray & out_allowed_curves) const;
1588  };
1589 
1591  class EXCHANGE_API ImportOptionsKit : public SprocketKit
1592  {
1593  public:
1595  ImportOptionsKit();
1596 
1599  ImportOptionsKit(ImportOptionsKit const & in_kit);
1600 
1604  ImportOptionsKit(ImportOptionsKit && in_that);
1605 
1609  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
1610 
1611  virtual ~ImportOptionsKit();
1612 
1613  HPS::Type ObjectType() const { return HPS::Type::ExchangeImportOptionsKit; }
1614 
1618  static ImportOptionsKit GetDefault();
1619 
1622  void Set(ImportOptionsKit const & in_kit);
1623 
1626  void Show(ImportOptionsKit & out_kit) const;
1627 
1631  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
1632 
1635  bool Empty() const;
1636 
1640  bool Equals(ImportOptionsKit const & in_kit) const;
1641 
1645  bool operator==(ImportOptionsKit const & in_kit) const;
1646 
1650  bool operator!=(ImportOptionsKit const & in_kit) const;
1651 
1652 
1658  ImportOptionsKit & SetBRepData(bool in_state);
1659 
1665  ImportOptionsKit & SetBRepMode(BRepMode in_mode);
1666 
1672  ImportOptionsKit & SetSolids(bool in_state);
1673 
1679  ImportOptionsKit & SetSurfaces(bool in_state);
1680 
1686  ImportOptionsKit & SetWireframes(bool in_state);
1687 
1693  ImportOptionsKit & SetPMI(bool in_state);
1694 
1701  ImportOptionsKit & SetAttributes(bool in_state);
1702 
1708  ImportOptionsKit & SetHiddenObjects(bool in_state);
1709 
1715  ImportOptionsKit & SetConstructionAndReferences(bool in_state);
1716 
1722  ImportOptionsKit & SetActiveFilter(bool in_state);
1723 
1729  ImportOptionsKit & SetDefaultUnits(Units in_units);
1730 
1735  ImportOptionsKit & SetMultiProcessCount(unsigned int in_count);
1736 
1742  ImportOptionsKit & SetSewingTolerance(double in_tolerance);
1743 
1750  ImportOptionsKit & SetPMISubstitutionFont(char const * in_font_name, bool in_always_substitute = false);
1751 
1757  ImportOptionsKit & SetPMIPrecision(size_t in_precision);
1758 
1764  ImportOptionsKit & SetPMIDefaultUnits(Units in_units);
1765 
1773  ImportOptionsKit & SetPMIFlipping(bool in_flip);
1774 
1782  ImportOptionsKit & SetPMIDefaultColor(RGBColor const & in_color, bool in_override_color = false);
1783 
1789  ImportOptionsKit & SetTessellationCleanup(bool in_cleanup);
1790 
1796  ImportOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
1797 
1804  ImportOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
1805 
1813  ImportOptionsKit & SetTessellationAccuracy(Tessellation::Accuracy in_type, bool in_accurate_normals = true);
1814 
1820  ImportOptionsKit & SetTessellationPreservesUVPoints(bool in_state);
1821 
1827  ImportOptionsKit & SetTessellationMaximumEdgeLength(double in_length);
1828 
1834  ImportOptionsKit & SetTextureDirectories(size_t in_count, UTF8 const in_directories[]);
1835 
1840  ImportOptionsKit & SetTextureDirectories(UTF8Array const & in_directories);
1841 
1848  ImportOptionsKit & SetSearchDirectories(size_t in_count, UTF8 const in_directories[], bool const in_recurse_flags[]);
1849 
1855  ImportOptionsKit & SetSearchDirectories(UTF8Array const & in_directories, BoolArray const & in_recurse_flags);
1856 
1865  ImportOptionsKit & SetSearchDirectories(size_t in_count, UTF8 const in_directories[], UTF8 const in_logical_names[], bool const in_recurse_flags[]);
1866 
1875  ImportOptionsKit & SetSearchDirectories(UTF8Array const & in_directories, UTF8Array const & in_logical_names, BoolArray const & in_recurse_flags);
1876 
1882  ImportOptionsKit & SetSearchDirectoriesByFile(size_t in_count, UTF8 const in_file_names[]);
1883 
1888  ImportOptionsKit & SetSearchDirectoriesByFile(UTF8Array const & in_file_names);
1889 
1894  ImportOptionsKit & SetConfiguration(char const * in_configuration);
1895 
1901  ImportOptionsKit & SetConfiguration(size_t in_count, UTF8 const in_configuration[]);
1902 
1907  ImportOptionsKit & SetConfiguration(UTF8Array const & in_configuration);
1908 
1914  ImportOptionsKit & SetCatiaV4LogicalNameForRootDirectory(char const * in_name);
1915 
1922  ImportOptionsKit & SetCatiaV4LogicalNameSearching(bool in_state);
1923 
1930  ImportOptionsKit & SetCatiaV5Cache(bool in_active, char const * in_path);
1931 
1939  ImportOptionsKit & SetUnigraphicsPreferredReferenceSets(size_t in_count, UTF8 const in_reference_sets[], bool in_apply_to_all_levels);
1940 
1947  ImportOptionsKit & SetUnigraphicsPreferredReferenceSets(UTF8Array const & in_reference_sets, bool in_apply_to_all_levels);
1948 
1954  ImportOptionsKit & SetUnigraphicsFittedCamera(bool in_state);
1955 
1961  ImportOptionsKit & SetProECodePageName(char const * in_name);
1962 
1968  ImportOptionsKit & SetProEDimensionTolerance(bool in_state);
1969 
1975  ImportOptionsKit & SetProESubpartPMI(bool in_state);
1976 
1982  ImportOptionsKit & SetProESessionColor(ProE::SessionColor in_type);
1983 
1990  ImportOptionsKit & SetProEMissingBoolean(bool in_state);
1991 
1998  ImportOptionsKit & SetProEMissingFlexibleComponent(bool in_state);
1999 
2006  ImportOptionsKit & SetProEFamilyTableSource(ProE::FamilyTable in_source);
2007 
2014  ImportOptionsKit & SetProEHomeView(bool in_state);
2015 
2022  ImportOptionsKit & SetProEExplodedViews(bool in_state);
2023 
2030  ImportOptionsKit & SetProEDatum(bool in_state);
2031 
2032 
2039  ImportOptionsKit & SetProEConstructionEntities(ProE::ConstructionEntities in_state);
2040 
2047  ImportOptionsKit & SetProESkeletons(bool in_state);
2048 
2055  ImportOptionsKit & SetSTEPNamePreference(STEP::Field in_field);
2056 
2062  ImportOptionsKit & SetSTEPCodePageName(char const * in_name);
2063 
2069  ImportOptionsKit & SetSTEPFirstColorPreference(bool in_state);
2070 
2076  ImportOptionsKit & SetSTEPShellBasedSurfaceModelSplitting(bool in_state);
2077 
2083  ImportOptionsKit & SetSTEPOrientationHealing(bool in_state);
2084 
2090  ImportOptionsKit & SetSTEPValidationProperties(bool in_state);
2091 
2097  ImportOptionsKit & SetIFCCodePageName(char const * in_name);
2098 
2105  ImportOptionsKit & SetIFCAttributeXMLFile(char const * in_filename);
2106 
2112  ImportOptionsKit & SetIFCOwnerHistoryOptimization(bool in_state);
2113 
2119  ImportOptionsKit & SetIFCFaceOptimization(bool in_state);
2120 
2127  ImportOptionsKit & SetIFCEdges(bool in_state);
2128 
2134  ImportOptionsKit & SetIFCMetadata(bool in_state);
2135 
2141  ImportOptionsKit & SetPDF3DStreamIndex(size_t in_index);
2142 
2148  ImportOptionsKit & SetJTTessellationLevel(JT::TessellationLevel in_jt_tessellation_level);
2149 
2155  ImportOptionsKit & SetInventorEmbeddedTessellation(bool in_state);
2156 
2162  ImportOptionsKit & SetPRCReadHelper(bool in_use_helper);
2163 
2167  ImportOptionsKit & SetAnnotationCaptureFitting(AnnotationCaptureFitting in_fitting);
2168 
2180  ImportOptionsKit & SetLocation(ComponentPath const & in_path, MatrixKit const & in_transform = MatrixKit());
2181 
2193  ImportOptionsKit & SetMode(ImportMode in_mode);
2194 
2204  ImportOptionsKit & SetIncrementalComponentPath(HPS::ComponentPath const & in_path);
2205 
2213  ImportOptionsKit & SetIncrementalComponentPaths(size_t in_count, HPS::ComponentPath const in_paths[]);
2214 
2221  ImportOptionsKit & SetIncrementalComponentPaths(HPS::ComponentPathArray const & in_paths);
2222 
2226  ImportOptionsKit & SetNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit const & in_nurbs_conversion_options);
2227 
2232  ImportOptionsKit & SetGeometryDefaultColor(RGBAColor const & in_color);
2233 
2237  ImportOptionsKit & UnsetBRepData();
2238 
2241  ImportOptionsKit & UnsetBRepMode();
2242 
2245  ImportOptionsKit & UnsetSolids();
2246 
2249  ImportOptionsKit & UnsetSurfaces();
2250 
2253  ImportOptionsKit & UnsetWireframes();
2254 
2257  ImportOptionsKit & UnsetPMI();
2258 
2261  ImportOptionsKit & UnsetAttributes();
2262 
2265  ImportOptionsKit & UnsetHiddenObjects();
2266 
2269  ImportOptionsKit & UnsetConstructionAndReferences();
2270 
2273  ImportOptionsKit & UnsetActiveFilter();
2274 
2277  ImportOptionsKit & UnsetSewingTolerance();
2278 
2281  ImportOptionsKit & UnsetDefaultUnits();
2282 
2285  ImportOptionsKit & UnsetMultiProcessCount();
2286 
2289  ImportOptionsKit & UnsetPMISubstitutionFont();
2290 
2293  ImportOptionsKit & UnsetPMIPrecision();
2294 
2297  ImportOptionsKit & UnsetPMIDefaultUnits();
2298 
2301  ImportOptionsKit & UnsetPMIDefaultColor();
2302 
2305  ImportOptionsKit & UnsetTessellationLevel();
2306 
2309  ImportOptionsKit & UnsetTessellationAccuracy();
2310 
2313  ImportOptionsKit & UnsetTessellationCleanup();
2314 
2317  ImportOptionsKit & UnsetPMIFlipping();
2318 
2321  ImportOptionsKit & UnsetTessellationPreservesUVPoints();
2322 
2325  ImportOptionsKit & UnsetTessellationMaximumEdgeLength();
2326 
2329  ImportOptionsKit & UnsetTextureDirectories();
2330 
2333  ImportOptionsKit & UnsetSearchDirectories();
2334 
2337  ImportOptionsKit & UnsetSearchDirectoriesByFile();
2338 
2341  ImportOptionsKit & UnsetConfiguration();
2342 
2345  ImportOptionsKit & UnsetCatiaV4LogicalNameForRootDirectory();
2346 
2349  ImportOptionsKit & UnsetCatiaV4LogicalNameSearching();
2350 
2353  ImportOptionsKit & UnsetCatiaV5Cache();
2354 
2357  ImportOptionsKit & UnsetUnigraphicsPreferredReferenceSets();
2358 
2361  ImportOptionsKit & UnsetUnigraphicsFittedCamera();
2362 
2365  ImportOptionsKit & UnsetProECodePageName();
2366 
2369  ImportOptionsKit & UnsetProEDimensionTolerance();
2370 
2373  ImportOptionsKit & UnsetProESubpartPMI();
2374 
2377  ImportOptionsKit & UnsetProESessionColor();
2378 
2381  ImportOptionsKit & UnsetProEDatum();
2382 
2385  ImportOptionsKit & UnsetProEHomeView();
2386 
2389  ImportOptionsKit & UnsetProEExplodedViews();
2390 
2393  ImportOptionsKit & UnsetProEMissingBoolean();
2394 
2397  ImportOptionsKit & UnsetProEMissingFlexibleComponent();
2398 
2401  ImportOptionsKit & UnsetProEFamilyTreeSource();
2402 
2405  ImportOptionsKit & UnsetProEConstructionEntities();
2406 
2409  ImportOptionsKit & UnsetProESkeletons();
2410 
2413  ImportOptionsKit & UnsetSTEPNamePreference();
2414 
2417  ImportOptionsKit & UnsetSTEPFirstColorPreference();
2418 
2421  ImportOptionsKit & UnsetSTEPCodePageName();
2422 
2425  ImportOptionsKit & UnsetSTEPShellBasedSurfaceModelSplitting();
2426 
2429  ImportOptionsKit & UnsetSTEPOrientationHealing();
2430 
2433  ImportOptionsKit & UnsetSTEPValidationProperties();
2434 
2437  ImportOptionsKit & UnsetIFCCodePageName();
2438 
2441  ImportOptionsKit & UnsetIFCAttributeXMLFile();
2442 
2445  ImportOptionsKit & UnsetIFCOwnerHistoryOptimization();
2446 
2449  ImportOptionsKit & UnsetIFCFaceOptimization();
2450 
2453  ImportOptionsKit & UnsetIFCEdges();
2454 
2457  ImportOptionsKit & UnsetIFCMetadata();
2458 
2461  ImportOptionsKit & UnsetPDF3DStreamIndex();
2462 
2465  ImportOptionsKit & UnsetJTTessellationLevel();
2466 
2469  ImportOptionsKit & UnsetInventorEmbeddedTessellation();
2470 
2473  ImportOptionsKit & UnsetPRCReadHelper();
2474 
2477  ImportOptionsKit & UnsetAnnotationCaptureFitting();
2478 
2481  ImportOptionsKit & UnsetLocation();
2482 
2485  ImportOptionsKit & UnsetMode();
2486 
2489  ImportOptionsKit & UnsetIncrementalComponentPaths();
2490 
2493  ImportOptionsKit & UnsetNURBSConversion();
2494 
2497  ImportOptionsKit & UnsetGeometryDefaultColor();
2498 
2501  ImportOptionsKit & UnsetEverything();
2502 
2503 
2508  bool ShowBRepData(bool & out_state) const;
2509 
2513  bool ShowBRepMode(BRepMode & out_mode) const;
2514 
2518  bool ShowSolids(bool & out_state) const;
2519 
2523  bool ShowSurfaces(bool & out_state) const;
2524 
2528  bool ShowWireframes(bool & out_state) const;
2529 
2533  bool ShowPMI(bool & out_state) const;
2534 
2538  bool ShowAttributes(bool & out_state) const;
2539 
2543  bool ShowHiddenObjects(bool & out_state) const;
2544 
2548  bool ShowConstructionAndReferences(bool & out_state) const;
2549 
2553  bool ShowActiveFilter(bool & out_state) const;
2554 
2558  bool ShowSewingTolerance(double & out_tolerance) const;
2559 
2563  bool ShowDefaultUnits(Units & out_units) const;
2564 
2568  bool ShowMultiProcessCount(unsigned int & out_count) const;
2569 
2574  bool ShowPMISubstitutionFont(UTF8 & out_font_name, bool & out_always_substitute) const;
2575 
2579  bool ShowPMIPrecision(size_t & out_precision) const;
2580 
2584  bool ShowPMIDefaultUnits(Units & out_units) const;
2585 
2590  bool ShowPMIDefaultColor(RGBColor & out_color, bool & out_override) const;
2591 
2599  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
2600 
2605  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals) const;
2606 
2610  bool ShowTessellationCleanup(bool & out_cleanup) const;
2611 
2615  bool ShowPMIFlipping(bool & out_pmi_flipping) const;
2616 
2620  bool ShowTessellationPreservesUVPoints(bool & out_state) const;
2621 
2625  bool ShowTessellationMaximumEdgeLength(double & out_length) const;
2626 
2630  bool ShowTextureDirectories(UTF8Array & out_directories) const;
2631 
2637  bool ShowSearchDirectories(UTF8Array & out_directories, UTF8Array & out_logical_names, BoolArray & out_recurse_flags) const;
2638 
2642  bool ShowSearchDirectoriesByFile(UTF8Array & out_file_names) const;
2643 
2647  bool ShowConfiguration(UTF8Array & out_configuration) const;
2648 
2652  bool ShowCatiaV4LogicalNameForRootDirectory(UTF8 & out_name) const;
2653 
2657  bool ShowCatiaV4LogicalNameSearching(bool & out_state) const;
2658 
2663  bool ShowCatiaV5Cache(bool & out_active, UTF8 & out_path) const;
2664 
2669  bool ShowUnigraphicsPreferredReferenceSets(UTF8Array & out_reference_sets, bool & out_apply_to_all_levels) const;
2670 
2674  bool ShowUnigraphicsFittedCamera(bool & out_state) const;
2675 
2679  bool ShowProECodePageName(UTF8 & out_name) const;
2680 
2684  bool ShowProEDimensionTolerance(bool & out_state) const;
2685 
2689  bool ShowProESubpartPMI(bool & out_state) const;
2690 
2694  bool ShowProESessionColor(ProE::SessionColor & out_type) const;
2695 
2699  bool ShowProEDatum(bool & out_state) const;
2700 
2704  bool ShowProEHomeView(bool & out_state) const;
2705 
2709  bool ShowProEExplodedViews(bool & out_state) const;
2710 
2714  bool ShowProEMissingBoolean(bool & out_state) const;
2715 
2719  bool ShowProEMissingFlexibleComponent(bool & out_state) const;
2720 
2724  bool ShowProEFamilyTableSource(ProE::FamilyTable & out_source) const;
2725 
2729  bool ShowProEConstructionEntities(ProE::ConstructionEntities & out_state) const;
2730 
2734  bool ShowProESkeletons(bool & out_state) const;
2735 
2739  bool ShowSTEPNamePreference(STEP::Field & out_field) const;
2740 
2744  bool ShowSTEPFirstColorPreference(bool & out_state) const;
2745 
2749  bool ShowSTEPCodePageName(UTF8 & out_name) const;
2750 
2754  bool ShowSTEPShellBasedSurfaceModelSplitting(bool & out_state) const;
2755 
2759  bool ShowSTEPOrientationHealing(bool & out_state) const;
2760 
2764  bool ShowSTEPValidationProperties(bool & out_state) const;
2765 
2769  bool ShowIFCCodePageName(UTF8 & out_name) const;
2770 
2774  bool ShowIFCAttributeXMLFile(UTF8 & out_filename) const;
2775 
2779  bool ShowIFCOwnerHistoryOptimization(bool & out_state) const;
2780 
2784  bool ShowIFCFaceOptimization(bool & out_state) const;
2785 
2789  bool ShowIFCEdges(bool & out_state) const;
2790 
2794  bool ShowIFCMetadata(bool & out_state) const;
2795 
2799  bool ShowPDF3DStreamIndex(size_t & out_index) const;
2800 
2804  bool ShowJTTessellationLevel(JT::TessellationLevel & out_tessellation_level) const;
2805 
2809  bool ShowInventorEmbeddedTessellation(bool & out_state) const;
2810 
2814  bool ShowPRCReadHelper(bool & out_use_helper) const;
2815 
2819  bool ShowAnnotationCaptureFitting(AnnotationCaptureFitting & out_fitting) const;
2820 
2825  bool ShowLocation(ComponentPath & out_path, MatrixKit & out_transform) const;
2826 
2830  bool ShowMode(ImportMode & out_mode) const;
2831 
2835  bool ShowIncrementalComponentPaths(HPS::ComponentPathArray & out_paths) const;
2836 
2840  bool ShowNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit & out_nurbs_conversion_options) const;
2841 
2845  bool ShowGeometryDefaultColor(RGBAColor & out_color) const;
2846  };
2847 
2849  class EXCHANGE_API Translation
2850  {
2851  public:
2854  enum class Healing
2855  {
2856  Off,
2857  On,
2858  OnlyIfNotParasolid,
2859  };
2860 
2863  enum class AccurateEdges
2864  {
2865  Off,
2866  On,
2867  OnlyIfNotParasolid,
2868  };
2869 
2872  enum class Simplification
2873  {
2874  Off,
2875  On,
2876  OnlyIfNotParasolid,
2877  };
2878 
2881  enum class Merging
2882  {
2883  Off,
2884  On,
2885  OnlyIfNotParasolid,
2886  };
2887 
2888  private:
2890  Translation();
2891  };
2892 
2894  class EXCHANGE_API TranslationOptionsKit : public SprocketKit
2895  {
2896  public:
2899 
2903 
2908 
2912  TranslationOptionsKit & operator=(TranslationOptionsKit && in_that);
2913 
2914  virtual ~TranslationOptionsKit();
2915 
2916  HPS::Type ObjectType() const { return HPS::Type::ExchangeTranslationOptionsKit; }
2917 
2921  static TranslationOptionsKit GetDefault();
2922 
2925  void Set(TranslationOptionsKit const & in_kit);
2926 
2929  void Show(TranslationOptionsKit & out_kit) const;
2930 
2934  TranslationOptionsKit & operator=(TranslationOptionsKit const & in_kit);
2935 
2938  bool Empty() const;
2939 
2943  bool Equals(TranslationOptionsKit const & in_kit) const;
2944 
2948  bool operator==(TranslationOptionsKit const & in_kit) const;
2949 
2953  bool operator!=(TranslationOptionsKit const & in_kit) const;
2954 
2960  TranslationOptionsKit & SetSolidsAsFaces(bool in_state);
2961 
2967  TranslationOptionsKit & SetTessellation(bool in_state);
2968 
2974  TranslationOptionsKit & SetHiddenObjects(bool in_state);
2975 
2979  TranslationOptionsKit & SetApplication(char const * in_name);
2980 
2984  TranslationOptionsKit & SetVersion(char const * in_version);
2985 
2989  TranslationOptionsKit & SetHealing(Translation::Healing in_healing);
2990 
2994  TranslationOptionsKit & SetAccurateEdges(Translation::AccurateEdges in_accurate_edges);
2995 
2999  TranslationOptionsKit & SetSimplification(Translation::Simplification in_simplification);
3000 
3004  TranslationOptionsKit & SetEntityMerging(Translation::Merging in_merging);
3005 
3010  TranslationOptionsKit & SetSewing(bool in_state, double in_tolerance = 0.0);
3011 
3015  TranslationOptionsKit & SetDisjointFaces(bool in_state);
3016 
3019  TranslationOptionsKit & UnsetSolidsAsFaces();
3020 
3023  TranslationOptionsKit & UnsetTessellation();
3024 
3027  TranslationOptionsKit & UnsetHiddenObjects();
3028 
3031  TranslationOptionsKit & UnsetApplication();
3032 
3035  TranslationOptionsKit & UnsetVersion();
3036 
3039  TranslationOptionsKit & UnsetHealing();
3040 
3043  TranslationOptionsKit & UnsetAccurateEdges();
3044 
3047  TranslationOptionsKit & UnsetSimplification();
3048 
3051  TranslationOptionsKit & UnsetEntityMerging();
3052 
3055  TranslationOptionsKit & UnsetSewing();
3056 
3059  TranslationOptionsKit & UnsetDisjointFaces();
3060 
3063  TranslationOptionsKit & UnsetEverything();
3064 
3065 
3069  bool ShowSolidsAsFaces(bool & out_state) const;
3070 
3074  bool ShowTessellation(bool & out_state) const;
3075 
3079  bool ShowHiddenObjects(bool & out_state) const;
3080 
3084  bool ShowApplication(UTF8 & out_name) const;
3085 
3089  bool ShowVersion(UTF8 & out_version) const;
3090 
3094  bool ShowHealing(Translation::Healing & out_healing) const;
3095 
3099  bool ShowAccurateEdges(Translation::AccurateEdges & out_accurate_edges) const;
3100 
3104  bool ShowSimplification(Translation::Simplification & out_simplification) const;
3105 
3109  bool ShowEntityMerging(Translation::Merging & out_merging) const;
3110 
3115  bool ShowSewing(bool & out_state, double & out_tolerance) const;
3116 
3120  bool ShowDisjointFaces(bool & out_state) const;
3121 
3126  TranslationOptionsKit & SetMultiProcessCount(unsigned int in_count);
3127 
3130  TranslationOptionsKit & UnsetMultiProcessCount();
3131 
3135  bool ShowMultiProcessCount(unsigned int & out_count) const;
3136  };
3137 
3138 
3139 
3144  class EXCHANGE_API ModelFileImportOptionsKit : public SprocketKit
3145  {
3146  public:
3149 
3153 
3158 
3162  ModelFileImportOptionsKit & operator=(ModelFileImportOptionsKit && in_that);
3163 
3164  virtual ~ModelFileImportOptionsKit();
3165 
3166  HPS::Type ObjectType() const { return HPS::Type::ExchangeModelFileImportOptionsKit; }
3167 
3171  static ModelFileImportOptionsKit GetDefault();
3172 
3175  void Set(ModelFileImportOptionsKit const & in_kit);
3176 
3179  void Show(ModelFileImportOptionsKit & out_kit) const;
3180 
3184  ModelFileImportOptionsKit & operator=(ModelFileImportOptionsKit const & in_kit);
3185 
3188  bool Empty() const;
3189 
3193  bool Equals(ModelFileImportOptionsKit const & in_kit) const;
3194 
3198  bool operator==(ModelFileImportOptionsKit const & in_kit) const;
3199 
3203  bool operator!=(ModelFileImportOptionsKit const & in_kit) const;
3204 
3205 
3206  /* Dictates whether Visualize will flip pmi when rotating so that text / symbols remain readable.
3207  * \note If exchange reports that a markup does not contain leader lines, but the tessellation does contain lines that markup will not be
3208  * flipped. This is a precaution for models where the leader line geometry was included as part of the markup tessellation and
3209  * flipping the geometry would cause any present leader lines to point in the wrong direction.
3210  * \param in_cleanup Whether or not to have visualize flip pmi when rotating.
3211  * \return A reference to this ImportOptionsKit.
3212  */
3213  ModelFileImportOptionsKit & SetPMIFlipping(bool in_flip);
3214 
3220  ModelFileImportOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
3221 
3228  ModelFileImportOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
3229 
3237  ModelFileImportOptionsKit & SetTessellationAccuracy(Tessellation::Accuracy in_type, bool in_accurate_normals = true);
3238 
3239  /* Dictates whether Exchange tesselation data will be released from their parent representation items during import.
3240  * \warning Setting this option to true will cause future exports to output without tessellation data.
3241  * \param in_cleanup Whether to clean up tessellation data from representation items.
3242  * \return A reference to this ImportOptionsKit.
3243  */
3244  ModelFileImportOptionsKit & SetTessellationCleanup(bool in_cleanup);
3245 
3251  ModelFileImportOptionsKit & SetTessellationPreservesUVPoints(bool in_state);
3252 
3258  ModelFileImportOptionsKit & SetTessellationMaximumEdgeLength(double in_length);
3259 
3266  ModelFileImportOptionsKit & SetIFCEdges(bool in_state);
3267 
3271  ModelFileImportOptionsKit & SetAnnotationCaptureFitting(AnnotationCaptureFitting in_fitting);
3272 
3285  ModelFileImportOptionsKit & SetLocation(ComponentPath const & in_path, MatrixKit const & in_transform = MatrixKit());
3286 
3292  ModelFileImportOptionsKit & SetSewingTolerance(double in_tolerance);
3293 
3297  ModelFileImportOptionsKit & SetNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit const & in_nurbs_conversion_options);
3298 
3303  ModelFileImportOptionsKit & SetGeometryDefaultColor(RGBAColor const & in_color);
3304 
3305 
3308  ModelFileImportOptionsKit & UnsetTessellationLevel();
3309 
3312  ModelFileImportOptionsKit & UnsetTessellationAccuracy();
3313 
3316  ModelFileImportOptionsKit & UnsetTessellationCleanup();
3317 
3320  ModelFileImportOptionsKit & UnsetPMIFlipping();
3321 
3324  ModelFileImportOptionsKit & UnsetTessellationPreservesUVPoints();
3325 
3328  ModelFileImportOptionsKit & UnsetTessellationMaximumEdgeLength();
3329 
3332  ModelFileImportOptionsKit & UnsetIFCEdges();
3333 
3336  ModelFileImportOptionsKit & UnsetAnnotationCaptureFitting();
3337 
3340  ModelFileImportOptionsKit & UnsetLocation();
3341 
3344  ModelFileImportOptionsKit & UnsetSewingTolerance();
3345 
3348  ModelFileImportOptionsKit & UnsetNURBSConversion();
3349 
3352  ModelFileImportOptionsKit & UnsetGeometryDefaultColor();
3353 
3356  ModelFileImportOptionsKit & UnsetEverything();
3357 
3358 
3366  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
3367 
3372  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals) const;
3373 
3377  bool ShowTessellationCleanup(bool & out_cleanup) const;
3378 
3382  bool ShowPMIFlipping(bool & out_pmi_flipping) const;
3383 
3387  bool ShowTessellationPreservesUVPoints(bool & out_state) const;
3388 
3392  bool ShowTessellationMaximumEdgeLength(double & out_length) const;
3393 
3397  bool ShowIFCEdges(bool & out_state) const;
3398 
3402  bool ShowAnnotationCaptureFitting(AnnotationCaptureFitting & out_fitting) const;
3403 
3408  bool ShowLocation(ComponentPath & out_path, MatrixKit & out_transform) const;
3409 
3413  bool ShowSewingTolerance(double & out_tolerance) const;
3414 
3418  bool ShowNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit & out_nurbs_conversion_options) const;
3419 
3423  bool ShowGeometryDefaultColor(RGBAColor & out_color) const;
3424  };
3425 
3427  class EXCHANGE_API Export3MFOptionsKit : public SprocketKit
3428  {
3429  public:
3432 
3435  Export3MFOptionsKit(Export3MFOptionsKit const & in_kit);
3436 
3440 
3441  virtual ~Export3MFOptionsKit();
3442 
3443  HPS::Type ObjectType() const { return HPS::Type::ExchangeExport3MFOptionsKit; }
3444 
3448  static Export3MFOptionsKit GetDefault();
3449 
3452  void Set(Export3MFOptionsKit const & in_kit);
3453 
3456  void Show(Export3MFOptionsKit& out_kit) const;
3457 
3461  Export3MFOptionsKit & operator=(Export3MFOptionsKit const & in_kit);
3462 
3466  Export3MFOptionsKit & operator=(Export3MFOptionsKit && in_that);
3467 
3470  bool Empty() const;
3471 
3475  bool Equals(Export3MFOptionsKit const & in_kit) const;
3476 
3480  bool operator==(Export3MFOptionsKit const & in_kit) const;
3481 
3485  bool operator!=(Export3MFOptionsKit const & in_kit) const;
3486 
3491  Export3MFOptionsKit & SetAdditionalKeyPaths(KeyPathArray const & in_additional_key_paths);
3492 
3498  Export3MFOptionsKit & SetAdditionalKeyPaths(size_t in_count, KeyPath const in_additional_key_paths[]);
3499 
3502  Export3MFOptionsKit & UnsetAdditionalKeyPaths();
3503 
3507  bool ShowAdditionalKeyPaths(KeyPathArray & out_additional_key_paths) const;
3508 
3513  Export3MFOptionsKit & SetCurrentTessellationRetention(bool in_state, TessellationOptionsKit const & in_tessellation_kit = TessellationOptionsKit());
3514 
3517  Export3MFOptionsKit & UnsetCurrentTessellationRetention();
3518 
3523  bool ShowCurrentTessellationRetention(bool & out_state, Exchange::TessellationOptionsKit & out_tessellation_kit) const;
3524 
3528  Export3MFOptionsKit & SetDescription(char const * in_description);
3529 
3532  Export3MFOptionsKit & UnsetDescription();
3533 
3537  bool ShowDescription(HPS::UTF8 & out_state) const;
3538 
3542  Export3MFOptionsKit & SetCopyright(char const * in_state);
3543 
3546  Export3MFOptionsKit & UnsetCopyright();
3547 
3551  bool ShowCopyright(HPS::UTF8 & out_state) const;
3552 
3556  Export3MFOptionsKit & SetLicenseTerms(char const * in_license);
3557 
3560  Export3MFOptionsKit & UnsetLicenseTerms();
3561 
3565  bool ShowLicenseTerms(HPS::UTF8 & out_license) const;
3566 
3569  Export3MFOptionsKit & UnsetEverything();
3570  };
3571 
3573  class EXCHANGE_API ExportACISOptionsKit : public SprocketKit
3574  {
3575  public:
3578 
3582 
3586 
3587  virtual ~ExportACISOptionsKit();
3588 
3589  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportACISOptionsKit; }
3590 
3594  static ExportACISOptionsKit GetDefault();
3595 
3598  void Set(ExportACISOptionsKit const & in_kit);
3599 
3602  void Show(ExportACISOptionsKit & out_kit) const;
3603 
3607  ExportACISOptionsKit & operator=(ExportACISOptionsKit const & in_kit);
3608 
3612  ExportACISOptionsKit & operator=(ExportACISOptionsKit && in_that);
3613 
3616  bool Empty() const;
3617 
3621  bool Equals(ExportACISOptionsKit const & in_kit) const;
3622 
3626  bool operator==(ExportACISOptionsKit const & in_kit) const;
3627 
3631  bool operator!=(ExportACISOptionsKit const & in_kit) const;
3632 
3633 
3639  ExportACISOptionsKit & SetMillimeterUnits(bool in_state);
3640 
3646  ExportACISOptionsKit & SetBinary(bool in_state);
3647 
3648 
3651  ExportACISOptionsKit & UnsetMillimeterUnits();
3652 
3655  ExportACISOptionsKit & UnsetBinary();
3656 
3659  ExportACISOptionsKit & UnsetEverything();
3660 
3661 
3665  bool ShowMillimeterUnits(bool & out_state) const;
3666 
3670  bool ShowBinary(bool & out_state) const;
3671  };
3672 
3674  class EXCHANGE_API ExportIGESOptionsKit : public SprocketKit
3675  {
3676  public:
3679 
3683 
3687 
3688  virtual ~ExportIGESOptionsKit();
3689 
3690  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportIGESOptionsKit; }
3691 
3695  static ExportIGESOptionsKit GetDefault();
3696 
3699  void Set(ExportIGESOptionsKit const & in_kit);
3700 
3703  void Show(ExportIGESOptionsKit & out_kit) const;
3704 
3708  ExportIGESOptionsKit & operator=(ExportIGESOptionsKit const & in_kit);
3709 
3713  ExportIGESOptionsKit & operator=(ExportIGESOptionsKit && in_that);
3714 
3717  bool Empty() const;
3718 
3722  bool Equals(ExportIGESOptionsKit const & in_kit) const;
3723 
3727  bool operator==(ExportIGESOptionsKit const & in_kit) const;
3728 
3732  bool operator!=(ExportIGESOptionsKit const & in_kit) const;
3733 
3734 
3740  ExportIGESOptionsKit & SetAnalyticsAsNURBS(bool in_state);
3741 
3747  ExportIGESOptionsKit & SetFacetedAsWireframe(bool in_state);
3748 
3754  ExportIGESOptionsKit & SetSolidsAsFaces(bool in_state);
3755 
3761  ExportIGESOptionsKit & SetHiddenObjects(bool in_state);
3762 
3768  ExportIGESOptionsKit & SetTessellation(bool in_state);
3769 
3773  ExportIGESOptionsKit & SetApplication(char const * in_name);
3774 
3778  ExportIGESOptionsKit & SetVersion(char const * in_version);
3779 
3780 
3783  ExportIGESOptionsKit & UnsetAnalyticsAsNURBS();
3784 
3787  ExportIGESOptionsKit & UnsetFacetedAsWireframe();
3788 
3791  ExportIGESOptionsKit & UnsetSolidsAsFaces();
3792 
3795  ExportIGESOptionsKit & UnsetHiddenObjects();
3796 
3799  ExportIGESOptionsKit & UnsetTessellation();
3800 
3803  ExportIGESOptionsKit & UnsetApplication();
3804 
3807  ExportIGESOptionsKit & UnsetVersion();
3808 
3811  ExportIGESOptionsKit & UnsetEverything();
3812 
3813 
3817  bool ShowAnalyticsAsNURBS(bool & out_state) const;
3818 
3822  bool ShowFacetedAsWireframe(bool & out_state) const;
3823 
3827  bool ShowSolidsAsFaces(bool & out_state) const;
3828 
3832  bool ShowHiddenObjects(bool & out_state) const;
3833 
3837  bool ShowTessellation(bool & out_state) const;
3838 
3842  bool ShowApplication(UTF8 & out_name) const;
3843 
3847  bool ShowVersion(UTF8 & out_version) const;
3848  };
3849 
3851  class EXCHANGE_API ExportJTOptionsKit : public SprocketKit
3852  {
3853  public:
3856 
3859  ExportJTOptionsKit(ExportJTOptionsKit const & in_kit);
3860 
3864 
3865  virtual ~ExportJTOptionsKit();
3866 
3867  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportJTOptionsKit; }
3868 
3872  static ExportJTOptionsKit GetDefault();
3873 
3876  void Set(ExportJTOptionsKit const & in_kit);
3877 
3880  void Show(ExportJTOptionsKit & out_kit) const;
3881 
3885  ExportJTOptionsKit & operator=(ExportJTOptionsKit const & in_kit);
3886 
3890  ExportJTOptionsKit & operator=(ExportJTOptionsKit && in_that);
3891 
3894  bool Empty() const;
3895 
3899  bool Equals(ExportJTOptionsKit const & in_kit) const;
3900 
3904  bool operator==(ExportJTOptionsKit const & in_kit) const;
3905 
3909  bool operator!=(ExportJTOptionsKit const & in_kit) const;
3910 
3911 
3917  ExportJTOptionsKit & SetContent(JT::Content in_content);
3918 
3924  ExportJTOptionsKit & SetHiddenObjects(bool in_state);
3925 
3931  ExportJTOptionsKit & SetPMI(bool in_state);
3932 
3938  ExportJTOptionsKit & SetVersion(JT::Version in_version);
3939 
3940 
3943  ExportJTOptionsKit & UnsetContent();
3944 
3947  ExportJTOptionsKit & UnsetHiddenObjects();
3948 
3951  ExportJTOptionsKit & UnsetPMI();
3952 
3955  ExportJTOptionsKit & UnsetVersion();
3956 
3959  ExportJTOptionsKit & UnsetEverything();
3960 
3961 
3965  bool ShowContent(JT::Content & out_content) const;
3966 
3970  bool ShowHiddenObjects(bool & out_state) const;
3971 
3975  bool ShowPMI(bool & out_state) const;
3976 
3980  bool ShowVersion(JT::Version & out_version) const;
3981  };
3982 
3984  class EXCHANGE_API ExportParasolidOptionsKit : public SprocketKit
3985  {
3986  public:
3989 
3993 
3997 
3998  virtual ~ExportParasolidOptionsKit();
3999 
4000  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportParasolidOptionsKit; }
4001 
4005  static ExportParasolidOptionsKit GetDefault();
4006 
4009  void Set(ExportParasolidOptionsKit const & in_kit);
4010 
4013  void Show(ExportParasolidOptionsKit & out_kit) const;
4014 
4018  ExportParasolidOptionsKit & operator=(ExportParasolidOptionsKit const & in_kit);
4019 
4023  ExportParasolidOptionsKit & operator=(ExportParasolidOptionsKit && in_that);
4024 
4027  bool Empty() const;
4028 
4032  bool Equals(ExportParasolidOptionsKit const & in_kit) const;
4033 
4037  bool operator==(ExportParasolidOptionsKit const & in_kit) const;
4038 
4042  bool operator!=(ExportParasolidOptionsKit const & in_kit) const;
4043 
4044 
4050  ExportParasolidOptionsKit & SetSolidsAsFaces(bool in_state);
4051 
4057  ExportParasolidOptionsKit & SetTessellation(bool in_state);
4058 
4064  ExportParasolidOptionsKit & SetHiddenObjects(bool in_state);
4065 
4069  ExportParasolidOptionsKit & SetApplication(char const * in_name);
4070 
4074  ExportParasolidOptionsKit & SetVersion(char const * in_version);
4075 
4076 
4079  ExportParasolidOptionsKit & UnsetSolidsAsFaces();
4080 
4083  ExportParasolidOptionsKit & UnsetTessellation();
4084 
4087  ExportParasolidOptionsKit & UnsetHiddenObjects();
4088 
4091  ExportParasolidOptionsKit & UnsetApplication();
4092 
4095  ExportParasolidOptionsKit & UnsetVersion();
4096 
4099  ExportParasolidOptionsKit & UnsetEverything();
4100 
4101 
4105  bool ShowSolidsAsFaces(bool & out_state) const;
4106 
4110  bool ShowTessellation(bool & out_state) const;
4111 
4115  bool ShowHiddenObjects(bool & out_state) const;
4116 
4120  bool ShowApplication(UTF8 & out_name) const;
4121 
4125  bool ShowVersion(UTF8 & out_version) const;
4126  };
4127 
4129  class EXCHANGE_API ExportPRCOptionsKit : public SprocketKit
4130  {
4131  public:
4134 
4137  ExportPRCOptionsKit(ExportPRCOptionsKit const & in_kit);
4138 
4142 
4143  virtual ~ExportPRCOptionsKit();
4144 
4145  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportPRCOptionsKit; }
4146 
4150  static ExportPRCOptionsKit GetDefault();
4151 
4154  void Set(ExportPRCOptionsKit const & in_kit);
4155 
4158  void Show(ExportPRCOptionsKit & out_kit) const;
4159 
4163  ExportPRCOptionsKit & operator=(ExportPRCOptionsKit const & in_kit);
4164 
4168  ExportPRCOptionsKit & operator=(ExportPRCOptionsKit && in_that);
4169 
4172  bool Empty() const;
4173 
4177  bool Equals(ExportPRCOptionsKit const & in_kit) const;
4178 
4182  bool operator==(ExportPRCOptionsKit const & in_kit) const;
4183 
4187  bool operator!=(ExportPRCOptionsKit const & in_kit) const;
4188 
4189 
4195  ExportPRCOptionsKit & SetTessellationCompression(bool in_state);
4196 
4203  ExportPRCOptionsKit & SetBRepCompression(PRC::BRepCompression in_level);
4204 
4210  ExportPRCOptionsKit & SetBRepRemoval(bool in_state);
4211 
4217  ExportPRCOptionsKit & SetAttributeRemoval(bool in_state);
4218 
4223  ExportPRCOptionsKit & SetAdditionalKeyPaths(KeyPathArray const & in_additional_key_paths);
4224 
4230  ExportPRCOptionsKit & SetAdditionalKeyPaths(size_t in_count, KeyPath const in_additional_key_paths []);
4231 
4232 
4235  ExportPRCOptionsKit & UnsetTessellationCompression();
4236 
4239  ExportPRCOptionsKit & UnsetBRepCompression();
4240 
4243  ExportPRCOptionsKit & UnsetBRepRemoval();
4244 
4247  ExportPRCOptionsKit & UnsetAttributeRemoval();
4248 
4251  ExportPRCOptionsKit & UnsetAdditionalKeyPaths();
4252 
4255  ExportPRCOptionsKit & UnsetEverything();
4256 
4257 
4261  bool ShowTessellationCompression(bool & out_state) const;
4262 
4266  bool ShowBRepCompression(PRC::BRepCompression & out_level) const;
4267 
4271  bool ShowBRepRemoval(bool & out_state) const;
4272 
4276  bool ShowAttributeRemoval(bool & out_state) const;
4277 
4281  bool ShowAdditionalKeyPaths(KeyPathArray & out_additional_key_paths) const;
4282  };
4283 
4285  class EXCHANGE_API ExportSTEPOptionsKit : public SprocketKit
4286  {
4287  public:
4290 
4294 
4298 
4299  virtual ~ExportSTEPOptionsKit();
4300 
4301  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportSTEPOptionsKit; }
4302 
4306  static ExportSTEPOptionsKit GetDefault();
4307 
4310  void Set(ExportSTEPOptionsKit const & in_kit);
4311 
4314  void Show(ExportSTEPOptionsKit & out_kit) const;
4315 
4319  ExportSTEPOptionsKit & operator=(ExportSTEPOptionsKit const & in_kit);
4320 
4324  ExportSTEPOptionsKit & operator=(ExportSTEPOptionsKit && in_that);
4325 
4328  bool Empty() const;
4329 
4333  bool Equals(ExportSTEPOptionsKit const & in_kit) const;
4334 
4338  bool operator==(ExportSTEPOptionsKit const & in_kit) const;
4339 
4343  bool operator!=(ExportSTEPOptionsKit const & in_kit) const;
4344 
4345 
4351  ExportSTEPOptionsKit & SetFormat(STEP::Format in_format);
4352 
4358  ExportSTEPOptionsKit & SetAnalyticsAsNURBS(bool in_state);
4359 
4365  ExportSTEPOptionsKit & SetFacetedAsWireframe(bool in_state);
4366 
4372  ExportSTEPOptionsKit & SetNameShortening(bool in_state);
4373 
4377  ExportSTEPOptionsKit & SetApplication(char const * in_name);
4378 
4382  ExportSTEPOptionsKit & SetVersion(char const * in_version);
4383 
4387  ExportSTEPOptionsKit & SetPMI(bool in_state);
4388 
4392  ExportSTEPOptionsKit & SetCurves(bool in_state);
4393 
4397  ExportSTEPOptionsKit & SetAttributes(bool in_state);
4398 
4399 
4402  ExportSTEPOptionsKit & UnsetFormat();
4403 
4406  ExportSTEPOptionsKit & UnsetAnalyticsAsNURBS();
4407 
4410  ExportSTEPOptionsKit & UnsetFacetedAsWireframe();
4411 
4414  ExportSTEPOptionsKit & UnsetNameShortening();
4415 
4418  ExportSTEPOptionsKit & UnsetApplication();
4419 
4422  ExportSTEPOptionsKit & UnsetVersion();
4423 
4426  ExportSTEPOptionsKit & UnsetPMI();
4427 
4430  ExportSTEPOptionsKit & UnsetCurves();
4431 
4434  ExportSTEPOptionsKit & UnsetAttributes();
4435 
4438  ExportSTEPOptionsKit & UnsetEverything();
4439 
4440 
4444  bool ShowFormat(STEP::Format & out_format) const;
4445 
4449  bool ShowAnalyticsAsNURBS(bool & out_state) const;
4450 
4454  bool ShowFacetedAsWireframe(bool & out_state) const;
4455 
4459  bool ShowNameShortening(bool & out_state) const;
4460 
4464  bool ShowApplication(UTF8 & out_name) const;
4465 
4469  bool ShowVersion(UTF8 & out_version) const;
4470 
4474  bool ShowPMI(bool & out_state) const;
4475 
4479  bool ShowCurves(bool & out_state) const;
4480 
4484  bool ShowAttributes(bool & out_state) const;
4485  };
4486 
4488  class EXCHANGE_API ExportSTLOptionsKit : public SprocketKit
4489  {
4490  public:
4493 
4496  ExportSTLOptionsKit(ExportSTLOptionsKit const & in_kit);
4497 
4501 
4502  virtual ~ExportSTLOptionsKit();
4503 
4504  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportSTLOptionsKit; }
4505 
4509  static ExportSTLOptionsKit GetDefault();
4510 
4513  void Set(ExportSTLOptionsKit const & in_kit);
4514 
4517  void Show(ExportSTLOptionsKit & out_kit) const;
4518 
4522  ExportSTLOptionsKit & operator=(ExportSTLOptionsKit const & in_kit);
4523 
4527  ExportSTLOptionsKit & operator=(ExportSTLOptionsKit && in_that);
4528 
4531  bool Empty() const;
4532 
4536  bool Equals(ExportSTLOptionsKit const & in_kit) const;
4537 
4541  bool operator==(ExportSTLOptionsKit const & in_kit) const;
4542 
4546  bool operator!=(ExportSTLOptionsKit const & in_kit) const;
4547 
4548 
4554  ExportSTLOptionsKit & SetBinary(bool in_state);
4555 
4561  ExportSTLOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
4562 
4569  ExportSTLOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
4570 
4576  ExportSTLOptionsKit & SetTessellationAccuracy(Tessellation::Accuracy in_type);
4577 
4583  ExportSTLOptionsKit & SetCurrentTessellationRetention(bool in_state);
4584 
4591  ExportSTLOptionsKit & SetMaximumEdgeLength(double in_length);
4592 
4593 
4596  ExportSTLOptionsKit & UnsetBinary();
4597 
4600  ExportSTLOptionsKit & UnsetTessellationLevel();
4601 
4604  ExportSTLOptionsKit & UnsetTessellationAccuracy();
4605 
4608  ExportSTLOptionsKit & UnsetCurrentTessellationRetention();
4609 
4612  ExportSTLOptionsKit & UnsetMaximumEdgeLength();
4613 
4616  ExportSTLOptionsKit & UnsetEverything();
4617 
4618 
4622  bool ShowBinary(bool & out_state) const;
4623 
4631  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
4632 
4636  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type) const;
4637 
4641  bool ShowCurrentTessellationRetention(bool & out_state) const;
4642 
4646  bool ShowMaximumEdgeLength(double & out_length) const;
4647  };
4648 
4650  class EXCHANGE_API ExportU3DOptionsKit : public SprocketKit
4651  {
4652  public:
4655 
4658  ExportU3DOptionsKit(ExportU3DOptionsKit const & in_kit);
4659 
4663 
4664  virtual ~ExportU3DOptionsKit();
4665 
4666  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportU3DOptionsKit; }
4667 
4671  static ExportU3DOptionsKit GetDefault();
4672 
4675  void Set(ExportU3DOptionsKit const & in_kit);
4676 
4679  void Show(ExportU3DOptionsKit & out_kit) const;
4680 
4684  ExportU3DOptionsKit & operator=(ExportU3DOptionsKit const & in_kit);
4685 
4689  ExportU3DOptionsKit & operator=(ExportU3DOptionsKit && in_that);
4690 
4693  bool Empty() const;
4694 
4698  bool Equals(ExportU3DOptionsKit const & in_kit) const;
4699 
4703  bool operator==(ExportU3DOptionsKit const & in_kit) const;
4704 
4708  bool operator!=(ExportU3DOptionsKit const & in_kit) const;
4709 
4710 
4716  ExportU3DOptionsKit & SetVersion(U3D::Version in_version);
4717 
4722  ExportU3DOptionsKit & SetCompression(unsigned char in_level);
4723 
4724 
4727  ExportU3DOptionsKit & UnsetVersion();
4728 
4731  ExportU3DOptionsKit & UnsetCompression();
4732 
4735  ExportU3DOptionsKit & UnsetEverything();
4736 
4737 
4741  bool ShowVersion(U3D::Version & out_version) const;
4742 
4746  bool ShowCompression(unsigned char & out_level) const;
4747  };
4748 
4750  class EXCHANGE_API ExportXMLOptionsKit : public SprocketKit
4751  {
4752  public:
4755 
4758  ExportXMLOptionsKit(ExportXMLOptionsKit const & in_kit);
4759 
4763 
4764  virtual ~ExportXMLOptionsKit();
4765 
4766  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportXMLOptionsKit; }
4767 
4771  static ExportXMLOptionsKit GetDefault();
4772 
4775  void Set(ExportXMLOptionsKit const & in_kit);
4776 
4779  void Show(ExportXMLOptionsKit & out_kit) const;
4780 
4784  ExportXMLOptionsKit & operator=(ExportXMLOptionsKit const & in_kit);
4785 
4789  ExportXMLOptionsKit & operator=(ExportXMLOptionsKit && in_that);
4790 
4793  bool Empty() const;
4794 
4798  bool Equals(ExportXMLOptionsKit const & in_kit) const;
4799 
4803  bool operator==(ExportXMLOptionsKit const & in_kit) const;
4804 
4808  bool operator!=(ExportXMLOptionsKit const & in_kit) const;
4809 
4810 
4816  ExportXMLOptionsKit & SetMetadata(bool in_state);
4817 
4823  ExportXMLOptionsKit & SetTransformations(bool in_state);
4824 
4830  ExportXMLOptionsKit & SetMaterials(bool in_state);
4831 
4832 
4835  ExportXMLOptionsKit & UnsetMetadata();
4836 
4839  ExportXMLOptionsKit & UnsetTransformations();
4840 
4843  ExportXMLOptionsKit & UnsetMaterials();
4844 
4847  ExportXMLOptionsKit & UnsetEverything();
4848 
4849 
4853  bool ShowMetadata(bool & out_state) const;
4854 
4858  bool ShowTransformations(bool & out_state) const;
4859 
4863  bool ShowMaterials(bool & out_state) const;
4864  };
4865 
4867  class EXCHANGE_API TessellationOptionsKit : public SprocketKit
4868  {
4869  public:
4872 
4876 
4880 
4881  virtual ~TessellationOptionsKit();
4882 
4883  HPS::Type ObjectType() const { return HPS::Type::ExchangeTessellationOptionsKit; }
4884 
4888  static TessellationOptionsKit GetDefault();
4889 
4892  void Set(TessellationOptionsKit const & in_kit);
4893 
4896  void Show(TessellationOptionsKit & out_kit) const;
4897 
4901  TessellationOptionsKit & operator=(TessellationOptionsKit const & in_kit);
4902 
4906  TessellationOptionsKit & operator=(TessellationOptionsKit && in_that);
4907 
4910  bool Empty() const;
4911 
4915  bool Equals(TessellationOptionsKit const & in_kit) const;
4916 
4920  bool operator==(TessellationOptionsKit const & in_kit) const;
4921 
4925  bool operator!=(TessellationOptionsKit const & in_kit) const;
4926 
4927 
4931  TessellationOptionsKit & SetLevel(Tessellation::Level in_level);
4932 
4939  TessellationOptionsKit & SetLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
4940 
4946  TessellationOptionsKit & SetAccuracy(Tessellation::Accuracy in_type, bool in_accurate_normals = true);
4947 
4951  TessellationOptionsKit & SetUVPointPreservation(bool in_state);
4952 
4956  TessellationOptionsKit & SetMaximumEdgeLength(double in_length);
4957 
4958 
4961  TessellationOptionsKit & UnsetLevel();
4962 
4965  TessellationOptionsKit & UnsetAccuracy();
4966 
4969  TessellationOptionsKit & UnsetUVPointPreservation();
4970 
4973  TessellationOptionsKit & UnsetMaximumEdgeLength();
4974 
4977  TessellationOptionsKit & UnsetEverything();
4978 
4979 
4987  bool ShowLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
4988 
4993  bool ShowAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals) const;
4994 
4998  bool ShowUVPointPreservation(bool & out_state) const;
4999 
5003  bool ShowMaximumEdgeLength(double & out_length) const;
5004  };
5005 
5011  class EXCHANGE_API CommonMeasurementOperator : public Operator
5012  {
5013  public:
5014  enum class Tags
5015  {
5016  Name = 0,
5017  MeasurementType,
5018  Radius,
5019  Inverted,
5020  VectorX,
5021  VectorY,
5022  VectorZ,
5023  };
5024 
5026 
5027  CommonMeasurementOperator(Exchange::CADModel const & in_cad_model, MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
5028 
5030  virtual HPS::UTF8 GetName() const OVERRIDE { return "HPS_ExchangeCommonMeasurementOperator"; }
5031 
5032  virtual void OnViewAttached() OVERRIDE;
5033  virtual void OnViewDetached() OVERRIDE;
5034 
5035  Exchange::CADModel GetCADModel() const;
5036  void SetCADModel(Exchange::CADModel const & in_cad_model);
5037 
5039  size_t GetPrecision() const;
5040 
5043  void SetPrecision(size_t in_precision);
5044 
5046  MaterialMappingKit GetMaterial() const;
5047 
5050  void SetMaterial(MaterialMappingKit const & in_material_mapping);
5051 
5053  TextAttributeKit GetTextAttributes() const;
5054 
5057  void SetTextAttribute(TextAttributeKit const & in_text_attributes);
5058 
5060  SegmentKey GetMeasurementSegment() const;
5061 
5063  static UTF8 GetNewMeasurementSegmentName(HPS::UTF8 const & in_prefix);
5064 
5065  /* Deletes all measurements */
5066  void DeleteMeasurements();
5067 
5068  class EXCHANGE_API MeasurementInsertedEvent : public HPS::Event
5069  {
5070  public:
5073  {
5074  channel = GetClassID();
5075  consumable = false;
5076  }
5077 
5078  MeasurementInsertedEvent(HPS::Key const & in_measurement_key, HPS::View const & in_view) : Event()
5079  {
5080  channel = GetClassID();
5081  consumable = false;
5082  measurement_key = in_measurement_key;
5083  view = in_view;
5084  }
5085 
5088  MeasurementInsertedEvent(Event const & in_event) : Event(in_event)
5089  {
5090  if (in_event.GetChannel() == Object::ClassID<MeasurementInsertedEvent>())
5091  {
5092  auto that = static_cast<MeasurementInsertedEvent const &>(in_event);
5093  measurement_key = that.measurement_key;
5094  view = that.view;
5095  }
5096  else
5097  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
5098  }
5099 
5101 
5104  Event * Clone() const
5105  {
5106  MeasurementInsertedEvent * new_event = new MeasurementInsertedEvent(*this);
5107  return new_event;
5108  }
5109 
5110  Key measurement_key;
5111  View view;
5112  };
5113 
5114  class EXCHANGE_API MeasurementDeletedEvent : public HPS::Event
5115  {
5116  public:
5119  {
5120  channel = GetClassID();
5121  consumable = false;
5122  }
5123 
5124  MeasurementDeletedEvent(HPS::UTF8 const & in_measurement_name, HPS::View const & in_view) : Event()
5125  {
5126  channel = GetClassID();
5127  consumable = false;
5128  measurement_name = in_measurement_name;
5129  view = in_view;
5130  }
5131 
5134  MeasurementDeletedEvent(Event const & in_event) : Event(in_event)
5135  {
5136  if (in_event.GetChannel() == Object::ClassID<MeasurementDeletedEvent>())
5137  {
5138  auto that = static_cast<MeasurementDeletedEvent const &>(in_event);
5139  measurement_name = that.measurement_name;
5140  view = that.view;
5141  }
5142  else
5143  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
5144  }
5145 
5147 
5150  Event * Clone() const
5151  {
5152  MeasurementDeletedEvent * new_event = new MeasurementDeletedEvent(*this);
5153  return new_event;
5154  }
5155 
5156  UTF8 measurement_name;
5157  View view;
5158  };
5159 
5160  protected:
5161  Exchange::CADModel cad_model;
5162  size_t measurement_precision;
5163  UTF8 units;
5164  MaterialMappingKit materials;
5165  TextAttributeKit text_attributes;
5166  SegmentKey measurement_segment;
5167  GlyphDefinition left_arrow;
5168  GlyphDefinition right_arrow;
5169  SelectionOptionsKit selection_options;
5170  bool manipulate_measurement; //whether we are manipulating a previously entered measurement
5171  Vector camera_direction;
5172  PortfolioKey portfolio;
5173  SegmentKey style_segment;
5174  HighlightOptionsKit highlight_options;
5175 
5176  static size_t length_measurement_index;
5177  static size_t radius_measurement_index;
5178  static size_t distance_measurement_index;
5179  static size_t angle_measurement_index;
5180 
5181  void Tag(HPS::Key & tag, const char * message, Tags tag_index);
5182  void GetUnits();
5183  void SetGlyphColor();
5184  void GetCameraDirection();
5185  void SetupConstructionSegment();
5186  void PositionLinearMeasurementGeometry(WindowPoint const & window_cursor_location, KeyPath const & event_path, LineKey & leader_line_one, LineKey & leader_line_two,
5187  LineKey & measurement_line, LineKey & line_to_cursor, Point & original_point_one, Point & original_point_two, TextKey & text, UTF8 const & text_string,
5188  Point & distance_point_one, Point & distance_point_two, SegmentKey & current_measurement_segment, Plane const & measurement_plane = Plane(), Vector const & explicit_direction = Vector());
5189  float GetModelScale(Exchange::Component const & component);
5190  void SetMaterialsOnMeasurementSegment(HPS::SegmentKey const & set_materials_here, HPS::MaterialMappingKit const & materials_to_apply);
5191  };
5192 
5246  {
5247  public:
5248  enum class MeasurementType
5249  {
5250  PointToPoint,
5251  EdgeAndRadius,
5252  FeatureToFeature,
5253  FaceAngle,
5254  };
5255 
5257 
5258  MeasurementOperator(Exchange::CADModel const & in_cad_model, MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
5259 
5261  virtual HPS::UTF8 GetName() const OVERRIDE{ return "HPS_ExchangeMeasurementOperator"; }
5262 
5263  virtual void OnViewAttached() OVERRIDE;
5264  virtual void OnViewDetached() OVERRIDE;
5265 
5270  virtual bool OnMouseDown(MouseState const & in_state) OVERRIDE;
5271 
5275  virtual bool OnMouseUp(MouseState const & in_state) OVERRIDE;
5276 
5282  virtual bool OnMouseMove(MouseState const & in_state) OVERRIDE;
5283 
5288  virtual bool OnTouchDown(TouchState const & in_state) OVERRIDE;
5289 
5293  virtual bool OnTouchUp(TouchState const & in_state) OVERRIDE;
5294 
5300  virtual bool OnTouchMove(TouchState const & in_state) OVERRIDE;
5301 
5305  virtual bool OnKeyDown(KeyboardState const & in_state) OVERRIDE;
5306 
5307  /* Sets the type of measurement to insert.
5308  * \param in_measurement_type The type of measurement to insert.*/
5309  void SetMeasurementType(MeasurementType in_measurement_type);
5310 
5313  MeasurementType GetMeasurementType();
5314 
5315  /* Whether measurable geometry should be highlighted when mousing over it
5316  * \param in_highlighting Whether measurable geometry should be highlighted when mousing over it. */
5317  void SetMouseOverHighlighting(bool in_highlighting);
5318 
5319  /* Whether measurable geometry should be highlighted when mousing over it
5320  * \param in_highlighting Whether measurable geometry should be highlighted when mousing over it.
5321  * \param in_highlight_options_kit The highlight kit used for mouse over highlights */
5322  void SetMouseOverHighlighting(bool in_highlighting, HighlightOptionsKit const & in_highlight_options_kit);
5323 
5324  /* Whether measurable geometry is highlighted when mousing over it
5325  * \return <span class='code'>true</span> if measurable geometry is highlighted on mouse over, <span class='code'>false</span> otherwise. */
5326  bool GetMouseOverHighlighting();
5327 
5328  /* Returns the highlight option kit currently used for mouse over highlighting.
5329  * \return the highlight option kit currently used for mouse over highlighting. */
5330  HighlightOptionsKit GetHighlightOptions();
5331 
5332  /* Whether a measurement is currently being inserted or edited.
5333  * \return <span class='code'>true</span> if a measurement is being inserted or manipulated, <span class='code'>false</span> otherwise. */
5334  bool IsMeasurementActive();
5335 
5336  private:
5337  enum class EdgeType //used to determine the type of edge measured when using the EdgeAndRadius measurement type
5338  {
5339  Circle,
5340  Line,
5341  Generic,
5342  };
5343 
5344  class Surface //helper class containing surfaces properties. Used for the FeatureToFeature measurement type
5345  {
5346  public:
5347  Surface();
5348 
5349  enum class SurfaceType
5350  {
5351  Plane,
5352  ConeOrCylinder,
5353  Unsupported,
5354  };
5355 
5356  SurfaceType surface_type; //the type of surface being measured
5357  Point center; //the center point of the surface
5358  Vector normal; //the center line of surfaces of type Cylinder or Cone
5359  LineKey normal_points; //the line representing the center line of surfaces of type Cylinder or Cone
5360  ComponentPath path; //the component path to this surface
5361  };
5362 
5363  //bookkeeping
5364  MeasurementType measurement_type; //the type of measurement to be inserted
5365  MeasurementType temporary_measurement_type; //the type of the measurement to be edited
5366  TouchID tracked_touch_id; //the ID of the touch to track for OnTouchMove operations
5367  TouchID current_touch_id; //the ID of the touch being processed
5368  SegmentKey current_measurement; //segment of the measurement being inserted / edited
5369  bool operator_active; //whether a measurement is in progress
5370  bool end_measurement; //whether we should end the current measurement
5371  CanvasArray canvases; //canvases related to the view where this operator is attached
5372 
5373  //measurement anchors
5374  size_t anchors; //valid for point-to-point and face-angle measurements
5375  bool anchors_in_place; //true if all the anchors have been placed
5376  Point first_click_position; //position of the first anchor
5377  Point second_click_position; //position of the second anchor
5378 
5379  //geometry for linear measurements
5380  MarkerKey anchor_one; //marker corresponding to the start of the measurement
5381  MarkerKey anchor_two; //marker corresponding to the end of the measurement
5382  LineKey distance_line; //a line representing the distance measured
5383  LineKey leader_line_one; //line connecting the first anchor point to the distance line
5384  LineKey leader_line_two; //line connecting the second anchor point to the distance line
5385  Point distance_point_one; //intersection of leader_line_one and distance_line
5386  Point distance_point_two; //intersection of leader_line_two and distance_line
5387  LineKey line_to_cursor; //line extending from distance_point_one to the cursor
5388  TextKey text; //text representing the measurement and units
5389  UTF8 text_string; //the contents of the text
5390  Vector measurement_direction; //the direction of the measurement
5391  bool use_explicit_direction; //if true, we are moving the measurement along a specific vector, called explicit_direction
5392  Vector explicit_direction; //used if use_explicit_direction is true
5393 
5394  //geometry for radius measurement
5395  MarkerKey center_marker; //marker representing the center of the circle
5396  Point circle_center; //circle center
5397  float radius; //circle radius
5398 
5399  //edge specific data
5400  LineKey edge_line; //the edge being measured
5401  double edge_length; //length of the measured edge
5402  EdgeType edge_type; //the type of edge being measured
5403 
5404  //feature-to-feature specific data
5405  Surface surface_one; //data related to first selected surface
5406  Surface surface_two; //data related to second selected surface
5407  Plane measurement_plane; //the measurement plane
5408  LineKey current_normal; //the center line of surfaces of type Cone and Cylinder
5409 
5410  //angle specific data
5411  Vector leader_line_one_direction; //the direction of the first leader line
5412  Vector leader_line_two_direction; //the direction of the second leader line
5413  Vector first_face_normal; //the normal of the first selected face
5414  Vector second_face_normal; //the normal of the second selected face
5415  bool inverted_measurement; //the smallest of the two possible angles is always chosen. If the user wants the other angle, the measurement is marked as 'inverted'
5416  CircularArcKey measurement_arc; //an arc representing the measured angle
5417  LineKey line_to_leader_line; //line extending from one anchor to a leader line
5418  Vector mid_point_direction;
5419 
5420  //selection kits
5421  SelectionOptionsKit point_to_point_selection;
5422  SelectionOptionsKit edge_radius_selection;
5423  SelectionOptionsKit feature_to_feature_selection;
5424  SelectionOptionsKit angle_selection;
5425 
5426  //highlighting
5427  bool highlight_on_mouse_over; //whether measurable geometry should be highlighted on mouse over
5428  HighlightOptionsKit mouse_over_highlight_options; //the options used for mouse over highlighting
5429  HighlightOptionsKit edit_measurement_highlight_options; //the options used for highlighting measurements while editing them
5430  UpdateNotifier highlight_update_notifier; //notifier used to know if the last highlight update has completed
5431  KeyPath highlighted_path; //highlighted_path
5432  bool disable_highlighting; //in some situation we temporarily disable highlighting to improve performance
5433  bool Highlight(MeasurementType in_measurement_type, WindowPoint const & in_location, WindowKey & in_window, KeyPath const & in_path);
5434 
5435  //input handling
5436  bool InputDown(WindowPoint const & in_location, WindowKey & in_window, KeyPath const & in_path, size_t number_of_clicks);
5437  bool InputMove(WindowPoint const & in_location, KeyPath const & in_path);
5438  bool InputUp(WindowKey & in_window);
5439  void ResetMeasurement();
5440 
5441  //inserting measurements
5442  void InsertPointToPointMeasurement(Point const & in_world_point);
5443  bool InsertEdgeRadiusMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_edge_key);
5444  bool InsertFeatureToFeatureMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_face_key, WindowKey & in_window);
5445  void InsertFeatureToFeatureGeometry(Point const & point_one, Point const & point_two, float distance);
5446  bool InsertAngleMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_face_key, WindowKey & in_window, SelectionResults const & in_selection_results);
5447  void InvertMeasuredAngle(WindowKey & in_window);
5448  void AdjustLineToCursor(Point const & cursor_position);
5449 
5450  //saving measurements
5451  void TagMeasurement();
5452  void TagPointToPointMeasurement();
5453  void TagEdgeMeasurement();
5454  void TagRadiusMeasurement();
5455  void TagGenericEdgeMeasurement();
5456  void TagFeatureToFeatureMeasurement();
5457  void TagAngleMeasurement();
5458 
5459  //restoring measurements
5460  void RestoreMeasurement(SegmentKey const & measurement_segment);
5461  void RestorePointToPointMeasurement(SegmentKey const & measurement_segment);
5462  void RestoreEdgeMeasurement(SegmentKey const & measurement_segment);
5463  void RestoreRadiusMeasurement(SegmentKey const & measurement_segment);
5464  void RestoreGenericEdgeMeasurement(SegmentKey const & measurement_segment);
5465  void RestoreFeatureToFeatureMeasurement(SegmentKey const & measurement_segment);
5466  void RestoreAngleMeasurement(SegmentKey const & measurement_segment);
5467  void RestoreLinearMeasurement(SegmentKey const & measurement_segment);
5468 
5469  //topology functions
5470  void GetEdgeLengthAndType(Exchange::Component const & edge_component);
5471  void GetSurfaceType(Exchange::Component const & face_component, Surface & surface);
5472  void PlaneToCenterLineDistance();
5473  void PlaneToPlaneDistance();
5474  void LineToLineDistance();
5475  float LineSegmentDistance(Point & p0, Point & p1, Point & q0, Point & q1, LineKey & normal_one, LineKey & normal_two, Point & out_point_on_edge, Point & out_point_on_center_line, bool clamp = true);
5476  Point ClosestPointOnTriangleToPoint(Point const & p, Point const & a, Point const & b, Point const & c);
5477  float ClosestPointSegmentSegment(Point const & p1, Point const & q1, Point const & p2, Point const & q2, Point & c1, Point & c2);
5478  bool IsPlane(Exchange::Component const & face_component);
5479  Point GetPlaneIntersection(Plane const & in_plane, KeyPath const & in_key_path, WindowPoint const & in_window_point);
5480  };
5481 
5482 private:
5484  Exchange();
5485 };
5486 
5487 }
5488 
5489 #endif
Definition: hps.h:6205
Definition: sprk_exchange.h:4129
Level
Definition: sprk_exchange.h:848
ConstructionEntities
Definition: sprk_exchange.h:1008
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3867
Definition: sprk_exchange.h:44
Definition: sprk_exchange.h:959
Definition: sprk.h:264
HPS::Type ObjectType() const
Definition: sprk_exchange.h:270
Definition: sprk_exchange.h:1124
Definition: sprk_exchange.h:5011
An InvalidSpecificationException is thrown when a method is called with non-sensical or contradictory...
Definition: hps.h:5685
Units
Definition: sprk_exchange.h:63
Definition: sprk.h:66
Simplification
Definition: sprk_exchange.h:2872
Definition: sprk.h:100
Definition: sprk_exchange.h:598
Version
Definition: sprk_exchange.h:1029
Definition: sprk_exchange.h:3144
Definition: sprk_exchange.h:858
Definition: sprk_exchange.h:697
virtual HPS::UTF8 GetName() const OVERRIDE
Definition: sprk_exchange.h:5030
HPS::Type ObjectType() const
Definition: sprk_exchange.h:679
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4766
SurfaceType
Definition: sprk_exchange.h:780
Definition: hps.h:1683
Format
Definition: sprk_exchange.h:946
HPS::Type ObjectType() const
Definition: sprk_exchange.h:725
Definition: sprk_exchange.h:4750
Definition: sprk.h:234
Definition: hps.h:46516
Format
Definition: sprk_exchange.h:1129
Definition: hps.h:7713
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4145
Type
Definition: sprk_exchange.h:839
Definition: hps.h:15928
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3690
Definition: sprk_exchange.h:454
Definition: sprk_exchange.h:538
Definition: sprk_exchange.h:297
HPS::Type ObjectType() const
Definition: sprk_exchange.h:435
virtual HPS::UTF8 GetName() const OVERRIDE
Definition: sprk_exchange.h:5261
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4000
MeasurementInsertedEvent(Event const &in_event)
Definition: sprk_exchange.h:5088
HPS::Type ObjectType() const
Definition: sprk_exchange.h:132
Definition: sprk_exchange.h:1367
Definition: sprk_exchange.h:238
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4504
HPS::Type ObjectType() const
Definition: sprk_exchange.h:323
Definition: sprk_exchange.h:3851
Merging
Definition: sprk_exchange.h:2881
HPS::Type ObjectType() const
Definition: sprk_exchange.h:2916
Field
Definition: sprk_exchange.h:936
Definition: hps.h:46415
Definition: hps.h:40521
HPS::Type ObjectType() const
Definition: sprk_exchange.h:1078
Definition: sprk_exchange.h:3573
Definition: sprk_exchange.h:2894
Limit
Definition: sprk_exchange.h:863
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4301
Definition: hps.h:4385
TessellationLevel
Definition: sprk_exchange.h:910
Definition: sprk_exchange.h:834
Definition: sprk_exchange.h:4488
Definition: sprk_exchange.h:111
Definition: sprk_exchange.h:931
Definition: hps.h:4324
Definition: hps.h:7086
Definition: hps.h:45907
Definition: sprk_exchange.h:409
UnloadMode
Definition: sprk_exchange.h:80
Definition: hps.h:42478
Definition: hps.h:46303
AnnotationCaptureFitting
Definition: sprk_exchange.h:827
Definition: sprk_exchange.h:4650
Definition: sprk_exchange.h:896
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3589
Definition: hps.h:15321
Event * Clone() const
Definition: sprk_exchange.h:5150
intptr_t GetChannel() const
Definition: hps.h:6338
Definition: sprk_exchange.h:1024
SessionColor
Definition: sprk_exchange.h:983
Definition: sprk.h:1724
Definition: hps.h:46622
LoadStatus
Definition: sprk_exchange.h:95
Definition: hps.h:43558
Definition: hps.h:45426
CurveType
Definition: sprk_exchange.h:803
Definition: sprk_exchange.h:498
Definition: hps.h:6305
Definition: hps.h:13582
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4883
Definition: sprk_exchange.h:5245
Definition: sprk.h:473
HPS::Type ObjectType() const
Definition: sprk_exchange.h:1613
BRepCompression
Definition: sprk_exchange.h:964
Definition: sprk_parasolid.h:39
BRepMode
Definition: sprk_exchange.h:753
Definition: sprk.h:2038
ComponentType
Definition: sprk.h:1729
Accuracy
Definition: sprk_exchange.h:880
Definition: sprk_exchange.h:3427
Definition: sprk_exchange.h:3674
HPS::Type ObjectType() const
Definition: sprk_exchange.h:1389
MeasurementDeletedEvent(Event const &in_event)
Definition: sprk_exchange.h:5134
Definition: sprk.h:2357
FamilyTable
Definition: sprk_exchange.h:996
Content
Definition: sprk_exchange.h:901
Definition: sprk_exchange.h:1591
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3166
HPS::Type ObjectType() const
Definition: sprk_exchange.h:626
Definition: sprk.h:2456
static MouseButtons ButtonLeft()
Definition: hps.h:46025
Definition: hps.h:7632
Definition: sprk_exchange.h:978
AccurateEdges
Definition: sprk_exchange.h:2863
Event * Clone() const
Definition: sprk_exchange.h:5104
HPS::Type ObjectType() const
Definition: sprk_exchange.h:480
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4666
Definition: hps.h:9239
HPS::Type ObjectType() const
Definition: sprk_exchange.h:205
Definition: sprk_exchange.h:651
Definition: hps.h:23598
Healing
Definition: sprk_exchange.h:2854
Definition: sprk.h:2542
Definition: hps.h:29924
ImportMode
Definition: sprk_exchange.h:768
Definition: sprk_exchange.h:1041
Definition: hps.h:517
Definition: sprk.h:1093
Definition: sprk_exchange.h:2849
static Model CreateModel(char const *in_name="")
Definition: sprk_exchange.h:3984
Definition: sprk_exchange.h:173
Definition: hps.h:40018
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3443
Version
Definition: sprk_exchange.h:919
Definition: sprk_exchange.h:4867
HPS::Type ObjectType() const
Definition: sprk_exchange.h:566
Definition: hps.h:41131
Definition: sprk_exchange.h:4285