API Search || Global Search
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  DWG,
1140  DXF,
1141  IDEAS,
1142  IFC,
1143  IGES,
1144  Inventor,
1145  JT,
1146  KeyholeMarkupLanguage,
1147  LatticeXVL,
1148  OneSpaceDesigner,
1149  Parasolid,
1150  PDF,
1151  PRC,
1152  Rhino,
1153  NXUnigraphics,
1154  SolidEdge,
1155  SolidWorks,
1156  STEP,
1157  StereoLithography,
1158  ThreeDStudioMax,
1159  ThreeDXML,
1160  Universal3D,
1161  VDAFS,
1162  VRML,
1163  WavefrontObject,
1164  };
1165 
1167  static Format GetFormat(char const * in_file_name);
1168 
1172  static ConfigurationArray GetConfigurations(char const * in_file_name);
1173 
1185  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);
1186 
1192  static HPS::ImageKit GetThumbnailImage(const char * in_file_name);
1193 
1200  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
1201 
1208  static ImportNotifier Import(A3DAsmModelFile const * in_model_file, ModelFileImportOptionsKit const & in_options);
1209 
1217  static ImportNotifier Import(size_t in_byte_count, byte const in_prc_data[], ModelFileImportOptionsKit const & in_options);
1218 
1225  static ImportNotifier Import(ByteArray const & in_prc_data, ModelFileImportOptionsKit const & in_options);
1226 
1227 
1234  static TranslationNotifier Translate(char const * in_file_name, ImportOptionsKit const & in_options, TranslationOptionsKit const & in_translation_options);
1235 
1240  static ExportNotifier Export3MF(CADModel const & in_cad_model, char const * in_file_name, Export3MFOptionsKit const & in_options);
1241 
1247  static ExportNotifier Export3MF(KeyPathArray const & in_source, char const * in_file_name, Export3MFOptionsKit const & in_options);
1248 
1255  static ExportNotifier Export3MF(size_t in_count, KeyPath const in_source[], char const * in_file_name, Export3MFOptionsKit const & in_options);
1256 
1262  static ExportNotifier Export3MF(KeyPath in_source, char const * in_file_name, Export3MFOptionsKit const & in_options);
1263 
1268  static void ExportACIS(CADModel const & in_cad_model, char const * in_file_name, ExportACISOptionsKit const & in_options);
1269 
1274  static void ExportIGES(CADModel const & in_cad_model, char const * in_file_name, ExportIGESOptionsKit const & in_options);
1275 
1280  static void ExportJT(CADModel const & in_cad_model, char const * in_file_name, ExportJTOptionsKit const & in_options);
1281 
1286  static void ExportParasolid(CADModel const & in_cad_model, char const * in_file_name, ExportParasolidOptionsKit const & in_options);
1287 
1293  static ExportNotifier ExportPRC(CADModel const & in_cad_model, char const * in_file_name, ExportPRCOptionsKit const & in_options);
1294 
1300  static ExportNotifier ExportPRC(KeyPathArray const & in_source, char const * in_file_name, bool in_compress_tessellation = false);
1301 
1308  static ExportNotifier ExportPRC(size_t in_count, KeyPath const in_source [], char const * in_file_name, bool in_compress_tessellation = false);
1309 
1316  static ExportNotifier ExportPRC(KeyPath const & in_source, char const * in_file_name, bool in_compress_tessellation = false);
1317 
1321  static ExportNotifier ExportPRC(KeyPathArray const & in_source);
1322 
1327  static ExportNotifier ExportPRC(size_t in_count, KeyPath const in_source []);
1328 
1332  static ExportNotifier ExportPRC(KeyPath const & in_source);
1333 
1338  static void ExportSTEP(CADModel const & in_cad_model, char const * in_file_name, ExportSTEPOptionsKit const & in_options);
1339 
1344  static void ExportSTL(CADModel const & in_cad_model, char const * in_file_name, ExportSTLOptionsKit const & in_options);
1345 
1350  static void ExportU3D(CADModel const & in_cad_model, char const * in_file_name, ExportU3DOptionsKit const & in_options);
1351 
1355  static void ExportVRML(CADModel const & in_cad_model, char const * in_file_name);
1356 
1361  static void ExportXML(CADModel const & in_cad_model, char const * in_file_name, ExportXMLOptionsKit const & in_options);
1362 
1363  private:
1365  File();
1366  };
1367 
1369  class EXCHANGE_API NURBSConversionOptionsKit : public SprocketKit
1370  {
1371  public:
1374 
1378 
1383 
1387  NURBSConversionOptionsKit & operator=(NURBSConversionOptionsKit && in_that);
1388 
1389  virtual ~NURBSConversionOptionsKit();
1390 
1391  HPS::Type ObjectType() const { return HPS::Type::ExchangeNURBSConversionOptionsKit; }
1392 
1395  void Set(NURBSConversionOptionsKit const & in_kit);
1396 
1399  void Show(NURBSConversionOptionsKit & out_kit) const;
1400 
1404  NURBSConversionOptionsKit & operator=(NURBSConversionOptionsKit const & in_kit);
1405 
1408  bool Empty() const;
1409 
1413  bool Equals(NURBSConversionOptionsKit const & in_kit) const;
1414 
1418  bool operator==(NURBSConversionOptionsKit const & in_kit) const;
1419 
1423  bool operator!=(NURBSConversionOptionsKit const & in_kit) const;
1424 
1428  static NURBSConversionOptionsKit GetDefault();
1429 
1434  NURBSConversionOptionsKit & SetCrossSeamCurveReplacement(bool in_state);
1435 
1440  NURBSConversionOptionsKit & Set3DCurvesComputation(bool in_state);
1441 
1446  NURBSConversionOptionsKit & SetUVCurvesComputation(bool in_state, bool in_allow_cross_seam_curves);
1447 
1452  NURBSConversionOptionsKit & SetClosedFaceSplitting(bool in_state);
1453 
1458  NURBSConversionOptionsKit & SetPeriodicFaceSplitting(bool in_state);
1459 
1464  NURBSConversionOptionsKit & SetParameterization(bool in_state);
1465 
1470  NURBSConversionOptionsKit & SetTolerance(double in_tolerance);
1471 
1477  NURBSConversionOptionsKit & SetAllowedSurfaces(SurfaceTypeArray const & in_allowed_surfaces);
1478 
1485  NURBSConversionOptionsKit & SetAllowedSurfaces(size_t in_count, SurfaceType const in_allowed_surfaces []);
1486 
1492  NURBSConversionOptionsKit & SetAllowedCurves(CurveTypeArray const & in_allowed_curves);
1493 
1500  NURBSConversionOptionsKit & SetAllowedCurves(size_t in_count, CurveType const in_allowed_curves []);
1501 
1502 
1505  NURBSConversionOptionsKit & UnsetCrossSeamCurveReplacement();
1506 
1509  NURBSConversionOptionsKit & Unset3DCurvesComputation();
1510 
1513  NURBSConversionOptionsKit & UnsetUVCurvesComputation();
1514 
1517  NURBSConversionOptionsKit & UnsetClosedFaceSplitting();
1518 
1521  NURBSConversionOptionsKit & UnsetPeriodicFaceSplitting();
1522 
1525  NURBSConversionOptionsKit & UnsetParameterization();
1526 
1529  NURBSConversionOptionsKit & UnsetTolerance();
1530 
1533  NURBSConversionOptionsKit & UnsetAllowedSurfaces();
1534 
1537  NURBSConversionOptionsKit & UnsetAllowedCurves();
1538 
1541  NURBSConversionOptionsKit & UnsetEverything();
1542 
1543 
1544 
1548  bool ShowCrossSeamCurveReplacement(bool & out_state) const;
1549 
1553  bool Show3DCurvesComputation(bool & out_state) const;
1554 
1559  bool ShowUVCurvesComputation(bool & out_state, bool & out_allow_cross_seam_curves) const;
1560 
1564  bool ShowClosedFaceSplitting(bool & out_state) const;
1565 
1569  bool ShowPeriodicFaceSplitting(bool & out_state) const;
1570 
1574  bool ShowParameterization(bool & out_state) const;
1575 
1579  bool ShowTolerance(double & out_tolerance) const;
1580 
1584  bool ShowAllowedSurfaces(SurfaceTypeArray & out_allowed_surfaces) const;
1585 
1589  bool ShowAllowedCurves(CurveTypeArray & out_allowed_curves) const;
1590  };
1591 
1593  class EXCHANGE_API ImportOptionsKit : public SprocketKit
1594  {
1595  public:
1597  ImportOptionsKit();
1598 
1601  ImportOptionsKit(ImportOptionsKit const & in_kit);
1602 
1606  ImportOptionsKit(ImportOptionsKit && in_that);
1607 
1611  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
1612 
1613  virtual ~ImportOptionsKit();
1614 
1615  HPS::Type ObjectType() const { return HPS::Type::ExchangeImportOptionsKit; }
1616 
1620  static ImportOptionsKit GetDefault();
1621 
1624  void Set(ImportOptionsKit const & in_kit);
1625 
1628  void Show(ImportOptionsKit & out_kit) const;
1629 
1633  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
1634 
1637  bool Empty() const;
1638 
1642  bool Equals(ImportOptionsKit const & in_kit) const;
1643 
1647  bool operator==(ImportOptionsKit const & in_kit) const;
1648 
1652  bool operator!=(ImportOptionsKit const & in_kit) const;
1653 
1654 
1660  ImportOptionsKit & SetBRepMode(BRepMode in_mode);
1661 
1667  ImportOptionsKit & SetSolids(bool in_state);
1668 
1674  ImportOptionsKit & SetSurfaces(bool in_state);
1675 
1681  ImportOptionsKit & SetWireframes(bool in_state);
1682 
1688  ImportOptionsKit & SetPMI(bool in_state);
1689 
1696  ImportOptionsKit & SetAttributes(bool in_state);
1697 
1703  ImportOptionsKit & SetHiddenObjects(bool in_state);
1704 
1710  ImportOptionsKit & SetConstructionAndReferences(bool in_state);
1711 
1717  ImportOptionsKit & SetActiveFilter(bool in_state);
1718 
1726  ImportOptionsKit & SetFeatureTrees(bool in_state);
1727 
1733  ImportOptionsKit & SetDrawings(bool in_state);
1734 
1740  ImportOptionsKit & SetDefaultUnits(Units in_units);
1741 
1746  ImportOptionsKit & SetMultiProcessCount(unsigned int in_count);
1747 
1753  ImportOptionsKit & SetSewingTolerance(double in_tolerance);
1754 
1761  ImportOptionsKit & SetPMISubstitutionFont(char const * in_font_name, bool in_always_substitute = false);
1762 
1768  ImportOptionsKit & SetPMIPrecision(size_t in_precision);
1769 
1775  ImportOptionsKit & SetPMIDefaultUnits(Units in_units);
1776 
1784  ImportOptionsKit & SetPMIFlipping(bool in_flip);
1785 
1793  ImportOptionsKit & SetPMIDefaultColor(RGBColor const & in_color, bool in_override_color = false);
1794 
1800  ImportOptionsKit & SetTessellationCleanup(bool in_cleanup);
1801 
1807  ImportOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
1808 
1815  ImportOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
1816 
1824  ImportOptionsKit & SetTessellationAccuracy(Tessellation::Accuracy in_type, bool in_accurate_normals = true);
1825 
1831  ImportOptionsKit & SetTessellationPreservesUVPoints(bool in_state);
1832 
1838  ImportOptionsKit & SetTessellationMaximumEdgeLength(double in_length);
1839 
1845  ImportOptionsKit & SetTextureDirectories(size_t in_count, UTF8 const in_directories[]);
1846 
1851  ImportOptionsKit & SetTextureDirectories(UTF8Array const & in_directories);
1852 
1859  ImportOptionsKit & SetSearchDirectories(size_t in_count, UTF8 const in_directories[], bool const in_recurse_flags[]);
1860 
1866  ImportOptionsKit & SetSearchDirectories(UTF8Array const & in_directories, BoolArray const & in_recurse_flags);
1867 
1876  ImportOptionsKit & SetSearchDirectories(size_t in_count, UTF8 const in_directories[], UTF8 const in_logical_names[], bool const in_recurse_flags[]);
1877 
1886  ImportOptionsKit & SetSearchDirectories(UTF8Array const & in_directories, UTF8Array const & in_logical_names, BoolArray const & in_recurse_flags);
1887 
1893  ImportOptionsKit & SetSearchDirectoriesByFile(size_t in_count, UTF8 const in_file_names[]);
1894 
1899  ImportOptionsKit & SetSearchDirectoriesByFile(UTF8Array const & in_file_names);
1900 
1905  ImportOptionsKit & SetConfiguration(char const * in_configuration);
1906 
1912  ImportOptionsKit & SetConfiguration(size_t in_count, UTF8 const in_configuration[]);
1913 
1918  ImportOptionsKit & SetConfiguration(UTF8Array const & in_configuration);
1919 
1925  ImportOptionsKit & SetCatiaV4LogicalNameForRootDirectory(char const * in_name);
1926 
1933  ImportOptionsKit & SetCatiaV4LogicalNameSearching(bool in_state);
1934 
1941  ImportOptionsKit & SetCatiaV5Cache(bool in_active, char const * in_path);
1942 
1950  ImportOptionsKit & SetUnigraphicsPreferredReferenceSets(size_t in_count, UTF8 const in_reference_sets[], bool in_apply_to_all_levels);
1951 
1958  ImportOptionsKit & SetUnigraphicsPreferredReferenceSets(UTF8Array const & in_reference_sets, bool in_apply_to_all_levels);
1959 
1965  ImportOptionsKit & SetUnigraphicsFittedCamera(bool in_state);
1966 
1972  ImportOptionsKit & SetProECodePageName(char const * in_name);
1973 
1979  ImportOptionsKit & SetProEDimensionTolerance(bool in_state);
1980 
1986  ImportOptionsKit & SetProESubpartPMI(bool in_state);
1987 
1993  ImportOptionsKit & SetProESessionColor(ProE::SessionColor in_type);
1994 
2001  ImportOptionsKit & SetProEMissingBoolean(bool in_state);
2002 
2009  ImportOptionsKit & SetProEMissingFlexibleComponent(bool in_state);
2010 
2017  ImportOptionsKit & SetProEFamilyTableSource(ProE::FamilyTable in_source);
2018 
2025  ImportOptionsKit & SetProEHomeView(bool in_state);
2026 
2033  ImportOptionsKit & SetProEExplodedViews(bool in_state);
2034 
2041  ImportOptionsKit & SetProEDatum(bool in_state);
2042 
2043 
2050  ImportOptionsKit & SetProEConstructionEntities(ProE::ConstructionEntities in_state);
2051 
2058  ImportOptionsKit & SetProESkeletons(bool in_state);
2059 
2066  ImportOptionsKit & SetSTEPNamePreference(STEP::Field in_field);
2067 
2073  ImportOptionsKit & SetSTEPCodePageName(char const * in_name);
2074 
2080  ImportOptionsKit & SetSTEPFirstColorPreference(bool in_state);
2081 
2087  ImportOptionsKit & SetSTEPShellBasedSurfaceModelSplitting(bool in_state);
2088 
2094  ImportOptionsKit & SetSTEPOrientationHealing(bool in_state);
2095 
2101  ImportOptionsKit & SetSTEPValidationProperties(bool in_state);
2102 
2108  ImportOptionsKit & SetIFCCodePageName(char const * in_name);
2109 
2116  ImportOptionsKit & SetIFCAttributeXMLFile(char const * in_filename);
2117 
2123  ImportOptionsKit & SetIFCOwnerHistoryOptimization(bool in_state);
2124 
2130  ImportOptionsKit & SetIFCFaceOptimization(bool in_state);
2131 
2138  ImportOptionsKit & SetIFCEdges(bool in_state);
2139 
2145  ImportOptionsKit & SetIFCMetadata(bool in_state);
2146 
2152  ImportOptionsKit & SetPDF3DStreamIndex(size_t in_index);
2153 
2159  ImportOptionsKit & SetJTTessellationLevel(JT::TessellationLevel in_jt_tessellation_level);
2160 
2166  ImportOptionsKit & SetInventorEmbeddedTessellation(bool in_state);
2167 
2173  ImportOptionsKit & SetPRCReadHelper(bool in_use_helper);
2174 
2178  ImportOptionsKit & SetAnnotationCaptureFitting(AnnotationCaptureFitting in_fitting);
2179 
2191  ImportOptionsKit & SetLocation(ComponentPath const & in_path, MatrixKit const & in_transform = MatrixKit());
2192 
2204  ImportOptionsKit & SetMode(ImportMode in_mode);
2205 
2215  ImportOptionsKit & SetIncrementalComponentPath(HPS::ComponentPath const & in_path);
2216 
2224  ImportOptionsKit & SetIncrementalComponentPaths(size_t in_count, HPS::ComponentPath const in_paths[]);
2225 
2232  ImportOptionsKit & SetIncrementalComponentPaths(HPS::ComponentPathArray const & in_paths);
2233 
2237  ImportOptionsKit & SetNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit const & in_nurbs_conversion_options);
2238 
2243  ImportOptionsKit & SetGeometryDefaultColor(RGBAColor const & in_color);
2244 
2247  ImportOptionsKit & UnsetBRepMode();
2248 
2251  ImportOptionsKit & UnsetSolids();
2252 
2255  ImportOptionsKit & UnsetSurfaces();
2256 
2259  ImportOptionsKit & UnsetWireframes();
2260 
2263  ImportOptionsKit & UnsetPMI();
2264 
2267  ImportOptionsKit & UnsetAttributes();
2268 
2271  ImportOptionsKit & UnsetHiddenObjects();
2272 
2275  ImportOptionsKit & UnsetConstructionAndReferences();
2276 
2279  ImportOptionsKit & UnsetActiveFilter();
2280 
2283  ImportOptionsKit & UnsetDrawings();
2284 
2287  ImportOptionsKit & UnsetFeatureTrees();
2288 
2291  ImportOptionsKit & UnsetSewingTolerance();
2292 
2295  ImportOptionsKit & UnsetDefaultUnits();
2296 
2299  ImportOptionsKit & UnsetMultiProcessCount();
2300 
2303  ImportOptionsKit & UnsetPMISubstitutionFont();
2304 
2307  ImportOptionsKit & UnsetPMIPrecision();
2308 
2311  ImportOptionsKit & UnsetPMIDefaultUnits();
2312 
2315  ImportOptionsKit & UnsetPMIDefaultColor();
2316 
2319  ImportOptionsKit & UnsetTessellationLevel();
2320 
2323  ImportOptionsKit & UnsetTessellationAccuracy();
2324 
2327  ImportOptionsKit & UnsetTessellationCleanup();
2328 
2331  ImportOptionsKit & UnsetPMIFlipping();
2332 
2335  ImportOptionsKit & UnsetTessellationPreservesUVPoints();
2336 
2339  ImportOptionsKit & UnsetTessellationMaximumEdgeLength();
2340 
2343  ImportOptionsKit & UnsetTextureDirectories();
2344 
2347  ImportOptionsKit & UnsetSearchDirectories();
2348 
2351  ImportOptionsKit & UnsetSearchDirectoriesByFile();
2352 
2355  ImportOptionsKit & UnsetConfiguration();
2356 
2359  ImportOptionsKit & UnsetCatiaV4LogicalNameForRootDirectory();
2360 
2363  ImportOptionsKit & UnsetCatiaV4LogicalNameSearching();
2364 
2367  ImportOptionsKit & UnsetCatiaV5Cache();
2368 
2371  ImportOptionsKit & UnsetUnigraphicsPreferredReferenceSets();
2372 
2375  ImportOptionsKit & UnsetUnigraphicsFittedCamera();
2376 
2379  ImportOptionsKit & UnsetProECodePageName();
2380 
2383  ImportOptionsKit & UnsetProEDimensionTolerance();
2384 
2387  ImportOptionsKit & UnsetProESubpartPMI();
2388 
2391  ImportOptionsKit & UnsetProESessionColor();
2392 
2395  ImportOptionsKit & UnsetProEDatum();
2396 
2399  ImportOptionsKit & UnsetProEHomeView();
2400 
2403  ImportOptionsKit & UnsetProEExplodedViews();
2404 
2407  ImportOptionsKit & UnsetProEMissingBoolean();
2408 
2411  ImportOptionsKit & UnsetProEMissingFlexibleComponent();
2412 
2415  ImportOptionsKit & UnsetProEFamilyTreeSource();
2416 
2419  ImportOptionsKit & UnsetProEConstructionEntities();
2420 
2423  ImportOptionsKit & UnsetProESkeletons();
2424 
2427  ImportOptionsKit & UnsetSTEPNamePreference();
2428 
2431  ImportOptionsKit & UnsetSTEPFirstColorPreference();
2432 
2435  ImportOptionsKit & UnsetSTEPCodePageName();
2436 
2439  ImportOptionsKit & UnsetSTEPShellBasedSurfaceModelSplitting();
2440 
2443  ImportOptionsKit & UnsetSTEPOrientationHealing();
2444 
2447  ImportOptionsKit & UnsetSTEPValidationProperties();
2448 
2451  ImportOptionsKit & UnsetIFCCodePageName();
2452 
2455  ImportOptionsKit & UnsetIFCAttributeXMLFile();
2456 
2459  ImportOptionsKit & UnsetIFCOwnerHistoryOptimization();
2460 
2463  ImportOptionsKit & UnsetIFCFaceOptimization();
2464 
2467  ImportOptionsKit & UnsetIFCEdges();
2468 
2471  ImportOptionsKit & UnsetIFCMetadata();
2472 
2475  ImportOptionsKit & UnsetPDF3DStreamIndex();
2476 
2479  ImportOptionsKit & UnsetJTTessellationLevel();
2480 
2483  ImportOptionsKit & UnsetInventorEmbeddedTessellation();
2484 
2487  ImportOptionsKit & UnsetPRCReadHelper();
2488 
2491  ImportOptionsKit & UnsetAnnotationCaptureFitting();
2492 
2495  ImportOptionsKit & UnsetLocation();
2496 
2499  ImportOptionsKit & UnsetMode();
2500 
2503  ImportOptionsKit & UnsetIncrementalComponentPaths();
2504 
2507  ImportOptionsKit & UnsetNURBSConversion();
2508 
2511  ImportOptionsKit & UnsetGeometryDefaultColor();
2512 
2515  ImportOptionsKit & UnsetEverything();
2516 
2520  bool ShowBRepMode(BRepMode & out_mode) const;
2521 
2525  bool ShowSolids(bool & out_state) const;
2526 
2530  bool ShowSurfaces(bool & out_state) const;
2531 
2535  bool ShowWireframes(bool & out_state) const;
2536 
2540  bool ShowPMI(bool & out_state) const;
2541 
2545  bool ShowAttributes(bool & out_state) const;
2546 
2550  bool ShowHiddenObjects(bool & out_state) const;
2551 
2555  bool ShowConstructionAndReferences(bool & out_state) const;
2556 
2560  bool ShowActiveFilter(bool & out_state) const;
2561 
2565  bool ShowDrawings(bool & out_state) const;
2566 
2570  bool ShowFeatureTrees(bool & out_state) const;
2571 
2575  bool ShowSewingTolerance(double & out_tolerance) const;
2576 
2580  bool ShowDefaultUnits(Units & out_units) const;
2581 
2585  bool ShowMultiProcessCount(unsigned int & out_count) const;
2586 
2591  bool ShowPMISubstitutionFont(UTF8 & out_font_name, bool & out_always_substitute) const;
2592 
2596  bool ShowPMIPrecision(size_t & out_precision) const;
2597 
2601  bool ShowPMIDefaultUnits(Units & out_units) const;
2602 
2607  bool ShowPMIDefaultColor(RGBColor & out_color, bool & out_override) const;
2608 
2616  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
2617 
2622  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals) const;
2623 
2627  bool ShowTessellationCleanup(bool & out_cleanup) const;
2628 
2632  bool ShowPMIFlipping(bool & out_pmi_flipping) const;
2633 
2637  bool ShowTessellationPreservesUVPoints(bool & out_state) const;
2638 
2642  bool ShowTessellationMaximumEdgeLength(double & out_length) const;
2643 
2647  bool ShowTextureDirectories(UTF8Array & out_directories) const;
2648 
2654  bool ShowSearchDirectories(UTF8Array & out_directories, UTF8Array & out_logical_names, BoolArray & out_recurse_flags) const;
2655 
2659  bool ShowSearchDirectoriesByFile(UTF8Array & out_file_names) const;
2660 
2664  bool ShowConfiguration(UTF8Array & out_configuration) const;
2665 
2669  bool ShowCatiaV4LogicalNameForRootDirectory(UTF8 & out_name) const;
2670 
2674  bool ShowCatiaV4LogicalNameSearching(bool & out_state) const;
2675 
2680  bool ShowCatiaV5Cache(bool & out_active, UTF8 & out_path) const;
2681 
2686  bool ShowUnigraphicsPreferredReferenceSets(UTF8Array & out_reference_sets, bool & out_apply_to_all_levels) const;
2687 
2691  bool ShowUnigraphicsFittedCamera(bool & out_state) const;
2692 
2696  bool ShowProECodePageName(UTF8 & out_name) const;
2697 
2701  bool ShowProEDimensionTolerance(bool & out_state) const;
2702 
2706  bool ShowProESubpartPMI(bool & out_state) const;
2707 
2711  bool ShowProESessionColor(ProE::SessionColor & out_type) const;
2712 
2716  bool ShowProEDatum(bool & out_state) const;
2717 
2721  bool ShowProEHomeView(bool & out_state) const;
2722 
2726  bool ShowProEExplodedViews(bool & out_state) const;
2727 
2731  bool ShowProEMissingBoolean(bool & out_state) const;
2732 
2736  bool ShowProEMissingFlexibleComponent(bool & out_state) const;
2737 
2741  bool ShowProEFamilyTableSource(ProE::FamilyTable & out_source) const;
2742 
2746  bool ShowProEConstructionEntities(ProE::ConstructionEntities & out_state) const;
2747 
2751  bool ShowProESkeletons(bool & out_state) const;
2752 
2756  bool ShowSTEPNamePreference(STEP::Field & out_field) const;
2757 
2761  bool ShowSTEPFirstColorPreference(bool & out_state) const;
2762 
2766  bool ShowSTEPCodePageName(UTF8 & out_name) const;
2767 
2771  bool ShowSTEPShellBasedSurfaceModelSplitting(bool & out_state) const;
2772 
2776  bool ShowSTEPOrientationHealing(bool & out_state) const;
2777 
2781  bool ShowSTEPValidationProperties(bool & out_state) const;
2782 
2786  bool ShowIFCCodePageName(UTF8 & out_name) const;
2787 
2791  bool ShowIFCAttributeXMLFile(UTF8 & out_filename) const;
2792 
2796  bool ShowIFCOwnerHistoryOptimization(bool & out_state) const;
2797 
2801  bool ShowIFCFaceOptimization(bool & out_state) const;
2802 
2806  bool ShowIFCEdges(bool & out_state) const;
2807 
2811  bool ShowIFCMetadata(bool & out_state) const;
2812 
2816  bool ShowPDF3DStreamIndex(size_t & out_index) const;
2817 
2821  bool ShowJTTessellationLevel(JT::TessellationLevel & out_tessellation_level) const;
2822 
2826  bool ShowInventorEmbeddedTessellation(bool & out_state) const;
2827 
2831  bool ShowPRCReadHelper(bool & out_use_helper) const;
2832 
2836  bool ShowAnnotationCaptureFitting(AnnotationCaptureFitting & out_fitting) const;
2837 
2842  bool ShowLocation(ComponentPath & out_path, MatrixKit & out_transform) const;
2843 
2847  bool ShowMode(ImportMode & out_mode) const;
2848 
2852  bool ShowIncrementalComponentPaths(HPS::ComponentPathArray & out_paths) const;
2853 
2857  bool ShowNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit & out_nurbs_conversion_options) const;
2858 
2862  bool ShowGeometryDefaultColor(RGBAColor & out_color) const;
2863  };
2864 
2866  class EXCHANGE_API Translation
2867  {
2868  public:
2871  enum class Healing
2872  {
2873  Off,
2874  On,
2875  OnlyIfNotParasolid,
2876  };
2877 
2880  enum class AccurateEdges
2881  {
2882  Off,
2883  On,
2884  OnlyIfNotParasolid,
2885  };
2886 
2889  enum class Simplification
2890  {
2891  Off,
2892  On,
2893  OnlyIfNotParasolid,
2894  };
2895 
2898  enum class Merging
2899  {
2900  Off,
2901  On,
2902  OnlyIfNotParasolid,
2903  };
2904 
2905  private:
2907  Translation();
2908  };
2909 
2911  class EXCHANGE_API TranslationOptionsKit : public SprocketKit
2912  {
2913  public:
2916 
2920 
2925 
2929  TranslationOptionsKit & operator=(TranslationOptionsKit && in_that);
2930 
2931  virtual ~TranslationOptionsKit();
2932 
2933  HPS::Type ObjectType() const { return HPS::Type::ExchangeTranslationOptionsKit; }
2934 
2938  static TranslationOptionsKit GetDefault();
2939 
2942  void Set(TranslationOptionsKit const & in_kit);
2943 
2946  void Show(TranslationOptionsKit & out_kit) const;
2947 
2951  TranslationOptionsKit & operator=(TranslationOptionsKit const & in_kit);
2952 
2955  bool Empty() const;
2956 
2960  bool Equals(TranslationOptionsKit const & in_kit) const;
2961 
2965  bool operator==(TranslationOptionsKit const & in_kit) const;
2966 
2970  bool operator!=(TranslationOptionsKit const & in_kit) const;
2971 
2977  TranslationOptionsKit & SetSolidsAsFaces(bool in_state);
2978 
2984  TranslationOptionsKit & SetTessellation(bool in_state);
2985 
2991  TranslationOptionsKit & SetHiddenObjects(bool in_state);
2992 
2996  TranslationOptionsKit & SetApplication(char const * in_name);
2997 
3001  TranslationOptionsKit & SetVersion(char const * in_version);
3002 
3006  TranslationOptionsKit & SetHealing(Translation::Healing in_healing);
3007 
3011  TranslationOptionsKit & SetAccurateEdges(Translation::AccurateEdges in_accurate_edges);
3012 
3016  TranslationOptionsKit & SetSimplification(Translation::Simplification in_simplification);
3017 
3021  TranslationOptionsKit & SetEntityMerging(Translation::Merging in_merging);
3022 
3027  TranslationOptionsKit & SetSewing(bool in_state, double in_tolerance = 0.0);
3028 
3032  TranslationOptionsKit & SetDisjointFaces(bool in_state);
3033 
3036  TranslationOptionsKit & UnsetSolidsAsFaces();
3037 
3040  TranslationOptionsKit & UnsetTessellation();
3041 
3044  TranslationOptionsKit & UnsetHiddenObjects();
3045 
3048  TranslationOptionsKit & UnsetApplication();
3049 
3052  TranslationOptionsKit & UnsetVersion();
3053 
3056  TranslationOptionsKit & UnsetHealing();
3057 
3060  TranslationOptionsKit & UnsetAccurateEdges();
3061 
3064  TranslationOptionsKit & UnsetSimplification();
3065 
3068  TranslationOptionsKit & UnsetEntityMerging();
3069 
3072  TranslationOptionsKit & UnsetSewing();
3073 
3076  TranslationOptionsKit & UnsetDisjointFaces();
3077 
3080  TranslationOptionsKit & UnsetEverything();
3081 
3082 
3086  bool ShowSolidsAsFaces(bool & out_state) const;
3087 
3091  bool ShowTessellation(bool & out_state) const;
3092 
3096  bool ShowHiddenObjects(bool & out_state) const;
3097 
3101  bool ShowApplication(UTF8 & out_name) const;
3102 
3106  bool ShowVersion(UTF8 & out_version) const;
3107 
3111  bool ShowHealing(Translation::Healing & out_healing) const;
3112 
3116  bool ShowAccurateEdges(Translation::AccurateEdges & out_accurate_edges) const;
3117 
3121  bool ShowSimplification(Translation::Simplification & out_simplification) const;
3122 
3126  bool ShowEntityMerging(Translation::Merging & out_merging) const;
3127 
3132  bool ShowSewing(bool & out_state, double & out_tolerance) const;
3133 
3137  bool ShowDisjointFaces(bool & out_state) const;
3138 
3143  TranslationOptionsKit & SetMultiProcessCount(unsigned int in_count);
3144 
3147  TranslationOptionsKit & UnsetMultiProcessCount();
3148 
3152  bool ShowMultiProcessCount(unsigned int & out_count) const;
3153  };
3154 
3155 
3156 
3161  class EXCHANGE_API ModelFileImportOptionsKit : public SprocketKit
3162  {
3163  public:
3166 
3170 
3175 
3179  ModelFileImportOptionsKit & operator=(ModelFileImportOptionsKit && in_that);
3180 
3181  virtual ~ModelFileImportOptionsKit();
3182 
3183  HPS::Type ObjectType() const { return HPS::Type::ExchangeModelFileImportOptionsKit; }
3184 
3188  static ModelFileImportOptionsKit GetDefault();
3189 
3192  void Set(ModelFileImportOptionsKit const & in_kit);
3193 
3196  void Show(ModelFileImportOptionsKit & out_kit) const;
3197 
3201  ModelFileImportOptionsKit & operator=(ModelFileImportOptionsKit const & in_kit);
3202 
3205  bool Empty() const;
3206 
3210  bool Equals(ModelFileImportOptionsKit const & in_kit) const;
3211 
3215  bool operator==(ModelFileImportOptionsKit const & in_kit) const;
3216 
3220  bool operator!=(ModelFileImportOptionsKit const & in_kit) const;
3221 
3222 
3223  /* Dictates whether Visualize will flip pmi when rotating so that text / symbols remain readable.
3224  * \note If exchange reports that a markup does not contain leader lines, but the tessellation does contain lines that markup will not be
3225  * flipped. This is a precaution for models where the leader line geometry was included as part of the markup tessellation and
3226  * flipping the geometry would cause any present leader lines to point in the wrong direction.
3227  * \param in_cleanup Whether or not to have visualize flip pmi when rotating.
3228  * \return A reference to this ImportOptionsKit.
3229  */
3230  ModelFileImportOptionsKit & SetPMIFlipping(bool in_flip);
3231 
3237  ModelFileImportOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
3238 
3245  ModelFileImportOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
3246 
3254  ModelFileImportOptionsKit & SetTessellationAccuracy(Tessellation::Accuracy in_type, bool in_accurate_normals = true);
3255 
3256  /* Dictates whether Exchange tesselation data will be released from their parent representation items during import.
3257  * \warning Setting this option to true will cause future exports to output without tessellation data.
3258  * \param in_cleanup Whether to clean up tessellation data from representation items.
3259  * \return A reference to this ImportOptionsKit.
3260  */
3261  ModelFileImportOptionsKit & SetTessellationCleanup(bool in_cleanup);
3262 
3268  ModelFileImportOptionsKit & SetTessellationPreservesUVPoints(bool in_state);
3269 
3275  ModelFileImportOptionsKit & SetTessellationMaximumEdgeLength(double in_length);
3276 
3283  ModelFileImportOptionsKit & SetIFCEdges(bool in_state);
3284 
3288  ModelFileImportOptionsKit & SetAnnotationCaptureFitting(AnnotationCaptureFitting in_fitting);
3289 
3302  ModelFileImportOptionsKit & SetLocation(ComponentPath const & in_path, MatrixKit const & in_transform = MatrixKit());
3303 
3309  ModelFileImportOptionsKit & SetSewingTolerance(double in_tolerance);
3310 
3314  ModelFileImportOptionsKit & SetNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit const & in_nurbs_conversion_options);
3315 
3320  ModelFileImportOptionsKit & SetGeometryDefaultColor(RGBAColor const & in_color);
3321 
3322 
3325  ModelFileImportOptionsKit & UnsetTessellationLevel();
3326 
3329  ModelFileImportOptionsKit & UnsetTessellationAccuracy();
3330 
3333  ModelFileImportOptionsKit & UnsetTessellationCleanup();
3334 
3337  ModelFileImportOptionsKit & UnsetPMIFlipping();
3338 
3341  ModelFileImportOptionsKit & UnsetTessellationPreservesUVPoints();
3342 
3345  ModelFileImportOptionsKit & UnsetTessellationMaximumEdgeLength();
3346 
3349  ModelFileImportOptionsKit & UnsetIFCEdges();
3350 
3353  ModelFileImportOptionsKit & UnsetAnnotationCaptureFitting();
3354 
3357  ModelFileImportOptionsKit & UnsetLocation();
3358 
3361  ModelFileImportOptionsKit & UnsetSewingTolerance();
3362 
3365  ModelFileImportOptionsKit & UnsetNURBSConversion();
3366 
3369  ModelFileImportOptionsKit & UnsetGeometryDefaultColor();
3370 
3373  ModelFileImportOptionsKit & UnsetEverything();
3374 
3375 
3383  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
3384 
3389  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals) const;
3390 
3394  bool ShowTessellationCleanup(bool & out_cleanup) const;
3395 
3399  bool ShowPMIFlipping(bool & out_pmi_flipping) const;
3400 
3404  bool ShowTessellationPreservesUVPoints(bool & out_state) const;
3405 
3409  bool ShowTessellationMaximumEdgeLength(double & out_length) const;
3410 
3414  bool ShowIFCEdges(bool & out_state) const;
3415 
3419  bool ShowAnnotationCaptureFitting(AnnotationCaptureFitting & out_fitting) const;
3420 
3425  bool ShowLocation(ComponentPath & out_path, MatrixKit & out_transform) const;
3426 
3430  bool ShowSewingTolerance(double & out_tolerance) const;
3431 
3435  bool ShowNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit & out_nurbs_conversion_options) const;
3436 
3440  bool ShowGeometryDefaultColor(RGBAColor & out_color) const;
3441  };
3442 
3444  class EXCHANGE_API Export3MFOptionsKit : public SprocketKit
3445  {
3446  public:
3449 
3452  Export3MFOptionsKit(Export3MFOptionsKit const & in_kit);
3453 
3457 
3458  virtual ~Export3MFOptionsKit();
3459 
3460  HPS::Type ObjectType() const { return HPS::Type::ExchangeExport3MFOptionsKit; }
3461 
3465  static Export3MFOptionsKit GetDefault();
3466 
3469  void Set(Export3MFOptionsKit const & in_kit);
3470 
3473  void Show(Export3MFOptionsKit& out_kit) const;
3474 
3478  Export3MFOptionsKit & operator=(Export3MFOptionsKit const & in_kit);
3479 
3483  Export3MFOptionsKit & operator=(Export3MFOptionsKit && in_that);
3484 
3487  bool Empty() const;
3488 
3492  bool Equals(Export3MFOptionsKit const & in_kit) const;
3493 
3497  bool operator==(Export3MFOptionsKit const & in_kit) const;
3498 
3502  bool operator!=(Export3MFOptionsKit const & in_kit) const;
3503 
3508  Export3MFOptionsKit & SetAdditionalKeyPaths(KeyPathArray const & in_additional_key_paths);
3509 
3515  Export3MFOptionsKit & SetAdditionalKeyPaths(size_t in_count, KeyPath const in_additional_key_paths[]);
3516 
3519  Export3MFOptionsKit & UnsetAdditionalKeyPaths();
3520 
3524  bool ShowAdditionalKeyPaths(KeyPathArray & out_additional_key_paths) const;
3525 
3530  Export3MFOptionsKit & SetCurrentTessellationRetention(bool in_state, TessellationOptionsKit const & in_tessellation_kit = TessellationOptionsKit());
3531 
3534  Export3MFOptionsKit & UnsetCurrentTessellationRetention();
3535 
3540  bool ShowCurrentTessellationRetention(bool & out_state, Exchange::TessellationOptionsKit & out_tessellation_kit) const;
3541 
3545  Export3MFOptionsKit & SetDescription(char const * in_description);
3546 
3549  Export3MFOptionsKit & UnsetDescription();
3550 
3554  bool ShowDescription(HPS::UTF8 & out_state) const;
3555 
3559  Export3MFOptionsKit & SetCopyright(char const * in_state);
3560 
3563  Export3MFOptionsKit & UnsetCopyright();
3564 
3568  bool ShowCopyright(HPS::UTF8 & out_state) const;
3569 
3573  Export3MFOptionsKit & SetLicenseTerms(char const * in_license);
3574 
3577  Export3MFOptionsKit & UnsetLicenseTerms();
3578 
3582  bool ShowLicenseTerms(HPS::UTF8 & out_license) const;
3583 
3586  Export3MFOptionsKit & UnsetEverything();
3587  };
3588 
3590  class EXCHANGE_API ExportACISOptionsKit : public SprocketKit
3591  {
3592  public:
3595 
3599 
3603 
3604  virtual ~ExportACISOptionsKit();
3605 
3606  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportACISOptionsKit; }
3607 
3611  static ExportACISOptionsKit GetDefault();
3612 
3615  void Set(ExportACISOptionsKit const & in_kit);
3616 
3619  void Show(ExportACISOptionsKit & out_kit) const;
3620 
3624  ExportACISOptionsKit & operator=(ExportACISOptionsKit const & in_kit);
3625 
3629  ExportACISOptionsKit & operator=(ExportACISOptionsKit && in_that);
3630 
3633  bool Empty() const;
3634 
3638  bool Equals(ExportACISOptionsKit const & in_kit) const;
3639 
3643  bool operator==(ExportACISOptionsKit const & in_kit) const;
3644 
3648  bool operator!=(ExportACISOptionsKit const & in_kit) const;
3649 
3650 
3656  ExportACISOptionsKit & SetMillimeterUnits(bool in_state);
3657 
3663  ExportACISOptionsKit & SetBinary(bool in_state);
3664 
3665 
3668  ExportACISOptionsKit & UnsetMillimeterUnits();
3669 
3672  ExportACISOptionsKit & UnsetBinary();
3673 
3676  ExportACISOptionsKit & UnsetEverything();
3677 
3678 
3682  bool ShowMillimeterUnits(bool & out_state) const;
3683 
3687  bool ShowBinary(bool & out_state) const;
3688  };
3689 
3691  class EXCHANGE_API ExportIGESOptionsKit : public SprocketKit
3692  {
3693  public:
3696 
3700 
3704 
3705  virtual ~ExportIGESOptionsKit();
3706 
3707  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportIGESOptionsKit; }
3708 
3712  static ExportIGESOptionsKit GetDefault();
3713 
3716  void Set(ExportIGESOptionsKit const & in_kit);
3717 
3720  void Show(ExportIGESOptionsKit & out_kit) const;
3721 
3725  ExportIGESOptionsKit & operator=(ExportIGESOptionsKit const & in_kit);
3726 
3730  ExportIGESOptionsKit & operator=(ExportIGESOptionsKit && in_that);
3731 
3734  bool Empty() const;
3735 
3739  bool Equals(ExportIGESOptionsKit const & in_kit) const;
3740 
3744  bool operator==(ExportIGESOptionsKit const & in_kit) const;
3745 
3749  bool operator!=(ExportIGESOptionsKit const & in_kit) const;
3750 
3751 
3757  ExportIGESOptionsKit & SetAnalyticsAsNURBS(bool in_state);
3758 
3764  ExportIGESOptionsKit & SetFacetedAsWireframe(bool in_state);
3765 
3771  ExportIGESOptionsKit & SetSolidsAsFaces(bool in_state);
3772 
3778  ExportIGESOptionsKit & SetHiddenObjects(bool in_state);
3779 
3785  ExportIGESOptionsKit & SetTessellation(bool in_state);
3786 
3790  ExportIGESOptionsKit & SetApplication(char const * in_name);
3791 
3795  ExportIGESOptionsKit & SetVersion(char const * in_version);
3796 
3797 
3800  ExportIGESOptionsKit & UnsetAnalyticsAsNURBS();
3801 
3804  ExportIGESOptionsKit & UnsetFacetedAsWireframe();
3805 
3808  ExportIGESOptionsKit & UnsetSolidsAsFaces();
3809 
3812  ExportIGESOptionsKit & UnsetHiddenObjects();
3813 
3816  ExportIGESOptionsKit & UnsetTessellation();
3817 
3820  ExportIGESOptionsKit & UnsetApplication();
3821 
3824  ExportIGESOptionsKit & UnsetVersion();
3825 
3828  ExportIGESOptionsKit & UnsetEverything();
3829 
3830 
3834  bool ShowAnalyticsAsNURBS(bool & out_state) const;
3835 
3839  bool ShowFacetedAsWireframe(bool & out_state) const;
3840 
3844  bool ShowSolidsAsFaces(bool & out_state) const;
3845 
3849  bool ShowHiddenObjects(bool & out_state) const;
3850 
3854  bool ShowTessellation(bool & out_state) const;
3855 
3859  bool ShowApplication(UTF8 & out_name) const;
3860 
3864  bool ShowVersion(UTF8 & out_version) const;
3865  };
3866 
3868  class EXCHANGE_API ExportJTOptionsKit : public SprocketKit
3869  {
3870  public:
3873 
3876  ExportJTOptionsKit(ExportJTOptionsKit const & in_kit);
3877 
3881 
3882  virtual ~ExportJTOptionsKit();
3883 
3884  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportJTOptionsKit; }
3885 
3889  static ExportJTOptionsKit GetDefault();
3890 
3893  void Set(ExportJTOptionsKit const & in_kit);
3894 
3897  void Show(ExportJTOptionsKit & out_kit) const;
3898 
3902  ExportJTOptionsKit & operator=(ExportJTOptionsKit const & in_kit);
3903 
3907  ExportJTOptionsKit & operator=(ExportJTOptionsKit && in_that);
3908 
3911  bool Empty() const;
3912 
3916  bool Equals(ExportJTOptionsKit const & in_kit) const;
3917 
3921  bool operator==(ExportJTOptionsKit const & in_kit) const;
3922 
3926  bool operator!=(ExportJTOptionsKit const & in_kit) const;
3927 
3928 
3934  ExportJTOptionsKit & SetContent(JT::Content in_content);
3935 
3941  ExportJTOptionsKit & SetHiddenObjects(bool in_state);
3942 
3948  ExportJTOptionsKit & SetPMI(bool in_state);
3949 
3955  ExportJTOptionsKit & SetVersion(JT::Version in_version);
3956 
3957 
3960  ExportJTOptionsKit & UnsetContent();
3961 
3964  ExportJTOptionsKit & UnsetHiddenObjects();
3965 
3968  ExportJTOptionsKit & UnsetPMI();
3969 
3972  ExportJTOptionsKit & UnsetVersion();
3973 
3976  ExportJTOptionsKit & UnsetEverything();
3977 
3978 
3982  bool ShowContent(JT::Content & out_content) const;
3983 
3987  bool ShowHiddenObjects(bool & out_state) const;
3988 
3992  bool ShowPMI(bool & out_state) const;
3993 
3997  bool ShowVersion(JT::Version & out_version) const;
3998  };
3999 
4001  class EXCHANGE_API ExportParasolidOptionsKit : public SprocketKit
4002  {
4003  public:
4006 
4010 
4014 
4015  virtual ~ExportParasolidOptionsKit();
4016 
4017  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportParasolidOptionsKit; }
4018 
4022  static ExportParasolidOptionsKit GetDefault();
4023 
4026  void Set(ExportParasolidOptionsKit const & in_kit);
4027 
4030  void Show(ExportParasolidOptionsKit & out_kit) const;
4031 
4035  ExportParasolidOptionsKit & operator=(ExportParasolidOptionsKit const & in_kit);
4036 
4040  ExportParasolidOptionsKit & operator=(ExportParasolidOptionsKit && in_that);
4041 
4044  bool Empty() const;
4045 
4049  bool Equals(ExportParasolidOptionsKit const & in_kit) const;
4050 
4054  bool operator==(ExportParasolidOptionsKit const & in_kit) const;
4055 
4059  bool operator!=(ExportParasolidOptionsKit const & in_kit) const;
4060 
4061 
4067  ExportParasolidOptionsKit & SetSolidsAsFaces(bool in_state);
4068 
4074  ExportParasolidOptionsKit & SetTessellation(bool in_state);
4075 
4081  ExportParasolidOptionsKit & SetHiddenObjects(bool in_state);
4082 
4086  ExportParasolidOptionsKit & SetApplication(char const * in_name);
4087 
4091  ExportParasolidOptionsKit & SetVersion(char const * in_version);
4092 
4093 
4096  ExportParasolidOptionsKit & UnsetSolidsAsFaces();
4097 
4100  ExportParasolidOptionsKit & UnsetTessellation();
4101 
4104  ExportParasolidOptionsKit & UnsetHiddenObjects();
4105 
4108  ExportParasolidOptionsKit & UnsetApplication();
4109 
4112  ExportParasolidOptionsKit & UnsetVersion();
4113 
4116  ExportParasolidOptionsKit & UnsetEverything();
4117 
4118 
4122  bool ShowSolidsAsFaces(bool & out_state) const;
4123 
4127  bool ShowTessellation(bool & out_state) const;
4128 
4132  bool ShowHiddenObjects(bool & out_state) const;
4133 
4137  bool ShowApplication(UTF8 & out_name) const;
4138 
4142  bool ShowVersion(UTF8 & out_version) const;
4143  };
4144 
4146  class EXCHANGE_API ExportPRCOptionsKit : public SprocketKit
4147  {
4148  public:
4151 
4154  ExportPRCOptionsKit(ExportPRCOptionsKit const & in_kit);
4155 
4159 
4160  virtual ~ExportPRCOptionsKit();
4161 
4162  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportPRCOptionsKit; }
4163 
4167  static ExportPRCOptionsKit GetDefault();
4168 
4171  void Set(ExportPRCOptionsKit const & in_kit);
4172 
4175  void Show(ExportPRCOptionsKit & out_kit) const;
4176 
4180  ExportPRCOptionsKit & operator=(ExportPRCOptionsKit const & in_kit);
4181 
4185  ExportPRCOptionsKit & operator=(ExportPRCOptionsKit && in_that);
4186 
4189  bool Empty() const;
4190 
4194  bool Equals(ExportPRCOptionsKit const & in_kit) const;
4195 
4199  bool operator==(ExportPRCOptionsKit const & in_kit) const;
4200 
4204  bool operator!=(ExportPRCOptionsKit const & in_kit) const;
4205 
4206 
4212  ExportPRCOptionsKit & SetTessellationCompression(bool in_state);
4213 
4220  ExportPRCOptionsKit & SetBRepCompression(PRC::BRepCompression in_level);
4221 
4227  ExportPRCOptionsKit & SetBRepRemoval(bool in_state);
4228 
4234  ExportPRCOptionsKit & SetAttributeRemoval(bool in_state);
4235 
4240  ExportPRCOptionsKit & SetAdditionalKeyPaths(KeyPathArray const & in_additional_key_paths);
4241 
4247  ExportPRCOptionsKit & SetAdditionalKeyPaths(size_t in_count, KeyPath const in_additional_key_paths []);
4248 
4249 
4252  ExportPRCOptionsKit & UnsetTessellationCompression();
4253 
4256  ExportPRCOptionsKit & UnsetBRepCompression();
4257 
4260  ExportPRCOptionsKit & UnsetBRepRemoval();
4261 
4264  ExportPRCOptionsKit & UnsetAttributeRemoval();
4265 
4268  ExportPRCOptionsKit & UnsetAdditionalKeyPaths();
4269 
4272  ExportPRCOptionsKit & UnsetEverything();
4273 
4274 
4278  bool ShowTessellationCompression(bool & out_state) const;
4279 
4283  bool ShowBRepCompression(PRC::BRepCompression & out_level) const;
4284 
4288  bool ShowBRepRemoval(bool & out_state) const;
4289 
4293  bool ShowAttributeRemoval(bool & out_state) const;
4294 
4298  bool ShowAdditionalKeyPaths(KeyPathArray & out_additional_key_paths) const;
4299  };
4300 
4302  class EXCHANGE_API ExportSTEPOptionsKit : public SprocketKit
4303  {
4304  public:
4307 
4311 
4315 
4316  virtual ~ExportSTEPOptionsKit();
4317 
4318  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportSTEPOptionsKit; }
4319 
4323  static ExportSTEPOptionsKit GetDefault();
4324 
4327  void Set(ExportSTEPOptionsKit const & in_kit);
4328 
4331  void Show(ExportSTEPOptionsKit & out_kit) const;
4332 
4336  ExportSTEPOptionsKit & operator=(ExportSTEPOptionsKit const & in_kit);
4337 
4341  ExportSTEPOptionsKit & operator=(ExportSTEPOptionsKit && in_that);
4342 
4345  bool Empty() const;
4346 
4350  bool Equals(ExportSTEPOptionsKit const & in_kit) const;
4351 
4355  bool operator==(ExportSTEPOptionsKit const & in_kit) const;
4356 
4360  bool operator!=(ExportSTEPOptionsKit const & in_kit) const;
4361 
4362 
4368  ExportSTEPOptionsKit & SetFormat(STEP::Format in_format);
4369 
4375  ExportSTEPOptionsKit & SetAnalyticsAsNURBS(bool in_state);
4376 
4382  ExportSTEPOptionsKit & SetFacetedAsWireframe(bool in_state);
4383 
4389  ExportSTEPOptionsKit & SetNameShortening(bool in_state);
4390 
4394  ExportSTEPOptionsKit & SetApplication(char const * in_name);
4395 
4399  ExportSTEPOptionsKit & SetVersion(char const * in_version);
4400 
4404  ExportSTEPOptionsKit & SetPMI(bool in_state);
4405 
4409  ExportSTEPOptionsKit & SetCurves(bool in_state);
4410 
4414  ExportSTEPOptionsKit & SetAttributes(bool in_state);
4415 
4416 
4419  ExportSTEPOptionsKit & UnsetFormat();
4420 
4423  ExportSTEPOptionsKit & UnsetAnalyticsAsNURBS();
4424 
4427  ExportSTEPOptionsKit & UnsetFacetedAsWireframe();
4428 
4431  ExportSTEPOptionsKit & UnsetNameShortening();
4432 
4435  ExportSTEPOptionsKit & UnsetApplication();
4436 
4439  ExportSTEPOptionsKit & UnsetVersion();
4440 
4443  ExportSTEPOptionsKit & UnsetPMI();
4444 
4447  ExportSTEPOptionsKit & UnsetCurves();
4448 
4451  ExportSTEPOptionsKit & UnsetAttributes();
4452 
4455  ExportSTEPOptionsKit & UnsetEverything();
4456 
4457 
4461  bool ShowFormat(STEP::Format & out_format) const;
4462 
4466  bool ShowAnalyticsAsNURBS(bool & out_state) const;
4467 
4471  bool ShowFacetedAsWireframe(bool & out_state) const;
4472 
4476  bool ShowNameShortening(bool & out_state) const;
4477 
4481  bool ShowApplication(UTF8 & out_name) const;
4482 
4486  bool ShowVersion(UTF8 & out_version) const;
4487 
4491  bool ShowPMI(bool & out_state) const;
4492 
4496  bool ShowCurves(bool & out_state) const;
4497 
4501  bool ShowAttributes(bool & out_state) const;
4502  };
4503 
4505  class EXCHANGE_API ExportSTLOptionsKit : public SprocketKit
4506  {
4507  public:
4510 
4513  ExportSTLOptionsKit(ExportSTLOptionsKit const & in_kit);
4514 
4518 
4519  virtual ~ExportSTLOptionsKit();
4520 
4521  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportSTLOptionsKit; }
4522 
4526  static ExportSTLOptionsKit GetDefault();
4527 
4530  void Set(ExportSTLOptionsKit const & in_kit);
4531 
4534  void Show(ExportSTLOptionsKit & out_kit) const;
4535 
4539  ExportSTLOptionsKit & operator=(ExportSTLOptionsKit const & in_kit);
4540 
4544  ExportSTLOptionsKit & operator=(ExportSTLOptionsKit && in_that);
4545 
4548  bool Empty() const;
4549 
4553  bool Equals(ExportSTLOptionsKit const & in_kit) const;
4554 
4558  bool operator==(ExportSTLOptionsKit const & in_kit) const;
4559 
4563  bool operator!=(ExportSTLOptionsKit const & in_kit) const;
4564 
4565 
4571  ExportSTLOptionsKit & SetBinary(bool in_state);
4572 
4578  ExportSTLOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
4579 
4586  ExportSTLOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
4587 
4593  ExportSTLOptionsKit & SetTessellationAccuracy(Tessellation::Accuracy in_type);
4594 
4600  ExportSTLOptionsKit & SetCurrentTessellationRetention(bool in_state);
4601 
4608  ExportSTLOptionsKit & SetMaximumEdgeLength(double in_length);
4609 
4619  ExportSTLOptionsKit & SetUnits(Units in_units);
4620 
4621 
4624  ExportSTLOptionsKit & UnsetBinary();
4625 
4628  ExportSTLOptionsKit & UnsetTessellationLevel();
4629 
4632  ExportSTLOptionsKit & UnsetTessellationAccuracy();
4633 
4636  ExportSTLOptionsKit & UnsetCurrentTessellationRetention();
4637 
4640  ExportSTLOptionsKit & UnsetMaximumEdgeLength();
4641 
4644  ExportSTLOptionsKit & UnsetUnits();
4645 
4648  ExportSTLOptionsKit & UnsetEverything();
4649 
4650 
4654  bool ShowBinary(bool & out_state) const;
4655 
4663  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
4664 
4668  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type) const;
4669 
4673  bool ShowCurrentTessellationRetention(bool & out_state) const;
4674 
4678  bool ShowMaximumEdgeLength(double & out_length) const;
4679 
4683  bool ShowUnits(Units & out_units) const;
4684  };
4685 
4687  class EXCHANGE_API ExportU3DOptionsKit : public SprocketKit
4688  {
4689  public:
4692 
4695  ExportU3DOptionsKit(ExportU3DOptionsKit const & in_kit);
4696 
4700 
4701  virtual ~ExportU3DOptionsKit();
4702 
4703  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportU3DOptionsKit; }
4704 
4708  static ExportU3DOptionsKit GetDefault();
4709 
4712  void Set(ExportU3DOptionsKit const & in_kit);
4713 
4716  void Show(ExportU3DOptionsKit & out_kit) const;
4717 
4721  ExportU3DOptionsKit & operator=(ExportU3DOptionsKit const & in_kit);
4722 
4726  ExportU3DOptionsKit & operator=(ExportU3DOptionsKit && in_that);
4727 
4730  bool Empty() const;
4731 
4735  bool Equals(ExportU3DOptionsKit const & in_kit) const;
4736 
4740  bool operator==(ExportU3DOptionsKit const & in_kit) const;
4741 
4745  bool operator!=(ExportU3DOptionsKit const & in_kit) const;
4746 
4747 
4753  ExportU3DOptionsKit & SetVersion(U3D::Version in_version);
4754 
4759  ExportU3DOptionsKit & SetCompression(unsigned char in_level);
4760 
4761 
4764  ExportU3DOptionsKit & UnsetVersion();
4765 
4768  ExportU3DOptionsKit & UnsetCompression();
4769 
4772  ExportU3DOptionsKit & UnsetEverything();
4773 
4774 
4778  bool ShowVersion(U3D::Version & out_version) const;
4779 
4783  bool ShowCompression(unsigned char & out_level) const;
4784  };
4785 
4787  class EXCHANGE_API ExportXMLOptionsKit : public SprocketKit
4788  {
4789  public:
4792 
4795  ExportXMLOptionsKit(ExportXMLOptionsKit const & in_kit);
4796 
4800 
4801  virtual ~ExportXMLOptionsKit();
4802 
4803  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportXMLOptionsKit; }
4804 
4808  static ExportXMLOptionsKit GetDefault();
4809 
4812  void Set(ExportXMLOptionsKit const & in_kit);
4813 
4816  void Show(ExportXMLOptionsKit & out_kit) const;
4817 
4821  ExportXMLOptionsKit & operator=(ExportXMLOptionsKit const & in_kit);
4822 
4826  ExportXMLOptionsKit & operator=(ExportXMLOptionsKit && in_that);
4827 
4830  bool Empty() const;
4831 
4835  bool Equals(ExportXMLOptionsKit const & in_kit) const;
4836 
4840  bool operator==(ExportXMLOptionsKit const & in_kit) const;
4841 
4845  bool operator!=(ExportXMLOptionsKit const & in_kit) const;
4846 
4847 
4853  ExportXMLOptionsKit & SetMetadata(bool in_state);
4854 
4860  ExportXMLOptionsKit & SetTransformations(bool in_state);
4861 
4867  ExportXMLOptionsKit & SetMaterials(bool in_state);
4868 
4869 
4872  ExportXMLOptionsKit & UnsetMetadata();
4873 
4876  ExportXMLOptionsKit & UnsetTransformations();
4877 
4880  ExportXMLOptionsKit & UnsetMaterials();
4881 
4884  ExportXMLOptionsKit & UnsetEverything();
4885 
4886 
4890  bool ShowMetadata(bool & out_state) const;
4891 
4895  bool ShowTransformations(bool & out_state) const;
4896 
4900  bool ShowMaterials(bool & out_state) const;
4901  };
4902 
4904  class EXCHANGE_API TessellationOptionsKit : public SprocketKit
4905  {
4906  public:
4909 
4913 
4917 
4918  virtual ~TessellationOptionsKit();
4919 
4920  HPS::Type ObjectType() const { return HPS::Type::ExchangeTessellationOptionsKit; }
4921 
4925  static TessellationOptionsKit GetDefault();
4926 
4929  void Set(TessellationOptionsKit const & in_kit);
4930 
4933  void Show(TessellationOptionsKit & out_kit) const;
4934 
4938  TessellationOptionsKit & operator=(TessellationOptionsKit const & in_kit);
4939 
4943  TessellationOptionsKit & operator=(TessellationOptionsKit && in_that);
4944 
4947  bool Empty() const;
4948 
4952  bool Equals(TessellationOptionsKit const & in_kit) const;
4953 
4957  bool operator==(TessellationOptionsKit const & in_kit) const;
4958 
4962  bool operator!=(TessellationOptionsKit const & in_kit) const;
4963 
4964 
4968  TessellationOptionsKit & SetLevel(Tessellation::Level in_level);
4969 
4976  TessellationOptionsKit & SetLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
4977 
4983  TessellationOptionsKit & SetAccuracy(Tessellation::Accuracy in_type, bool in_accurate_normals = true);
4984 
4988  TessellationOptionsKit & SetUVPointPreservation(bool in_state);
4989 
4993  TessellationOptionsKit & SetMaximumEdgeLength(double in_length);
4994 
4995 
4998  TessellationOptionsKit & UnsetLevel();
4999 
5002  TessellationOptionsKit & UnsetAccuracy();
5003 
5006  TessellationOptionsKit & UnsetUVPointPreservation();
5007 
5010  TessellationOptionsKit & UnsetMaximumEdgeLength();
5011 
5014  TessellationOptionsKit & UnsetEverything();
5015 
5016 
5024  bool ShowLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
5025 
5030  bool ShowAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals) const;
5031 
5035  bool ShowUVPointPreservation(bool & out_state) const;
5036 
5040  bool ShowMaximumEdgeLength(double & out_length) const;
5041  };
5042 
5048  class EXCHANGE_API CommonMeasurementOperator : public Operator
5049  {
5050  public:
5051  enum class Tags
5052  {
5053  Name = 0,
5054  MeasurementType,
5055  Radius,
5056  Inverted,
5057  VectorX,
5058  VectorY,
5059  VectorZ,
5060  };
5061 
5063 
5064  CommonMeasurementOperator(Exchange::CADModel const & in_cad_model, MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
5065 
5067  virtual HPS::UTF8 GetName() const OVERRIDE { return "HPS_ExchangeCommonMeasurementOperator"; }
5068 
5069  virtual void OnViewAttached() OVERRIDE;
5070  virtual void OnViewDetached() OVERRIDE;
5071 
5072  Exchange::CADModel GetCADModel() const;
5073  void SetCADModel(Exchange::CADModel const & in_cad_model);
5074 
5076  size_t GetPrecision() const;
5077 
5080  void SetPrecision(size_t in_precision);
5081 
5083  MaterialMappingKit GetMaterial() const;
5084 
5087  void SetMaterial(MaterialMappingKit const & in_material_mapping);
5088 
5090  TextAttributeKit GetTextAttributes() const;
5091 
5094  void SetTextAttribute(TextAttributeKit const & in_text_attributes);
5095 
5097  SegmentKey GetMeasurementSegment() const;
5098 
5100  static UTF8 GetNewMeasurementSegmentName(HPS::UTF8 const & in_prefix);
5101 
5102  /* Deletes all measurements */
5103  void DeleteMeasurements();
5104 
5105  class EXCHANGE_API MeasurementInsertedEvent : public HPS::Event
5106  {
5107  public:
5110  {
5111  channel = GetClassID();
5112  consumable = false;
5113  }
5114 
5115  MeasurementInsertedEvent(HPS::Key const & in_measurement_key, HPS::View const & in_view) : Event()
5116  {
5117  channel = GetClassID();
5118  consumable = false;
5119  measurement_key = in_measurement_key;
5120  view = in_view;
5121  }
5122 
5125  MeasurementInsertedEvent(Event const & in_event) : Event(in_event)
5126  {
5127  if (in_event.GetChannel() == Object::ClassID<MeasurementInsertedEvent>())
5128  {
5129  auto that = static_cast<MeasurementInsertedEvent const &>(in_event);
5130  measurement_key = that.measurement_key;
5131  view = that.view;
5132  }
5133  else
5134  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
5135  }
5136 
5138 
5141  Event * Clone() const
5142  {
5143  MeasurementInsertedEvent * new_event = new MeasurementInsertedEvent(*this);
5144  return new_event;
5145  }
5146 
5147  Key measurement_key;
5148  View view;
5149  };
5150 
5151  class EXCHANGE_API MeasurementDeletedEvent : public HPS::Event
5152  {
5153  public:
5156  {
5157  channel = GetClassID();
5158  consumable = false;
5159  }
5160 
5161  MeasurementDeletedEvent(HPS::UTF8 const & in_measurement_name, HPS::View const & in_view) : Event()
5162  {
5163  channel = GetClassID();
5164  consumable = false;
5165  measurement_name = in_measurement_name;
5166  view = in_view;
5167  }
5168 
5171  MeasurementDeletedEvent(Event const & in_event) : Event(in_event)
5172  {
5173  if (in_event.GetChannel() == Object::ClassID<MeasurementDeletedEvent>())
5174  {
5175  auto that = static_cast<MeasurementDeletedEvent const &>(in_event);
5176  measurement_name = that.measurement_name;
5177  view = that.view;
5178  }
5179  else
5180  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
5181  }
5182 
5184 
5187  Event * Clone() const
5188  {
5189  MeasurementDeletedEvent * new_event = new MeasurementDeletedEvent(*this);
5190  return new_event;
5191  }
5192 
5193  UTF8 measurement_name;
5194  View view;
5195  };
5196 
5197  protected:
5198  Exchange::CADModel cad_model;
5199  size_t measurement_precision;
5200  UTF8 units;
5201  MaterialMappingKit materials;
5202  TextAttributeKit text_attributes;
5203  SegmentKey measurement_segment;
5204  GlyphDefinition left_arrow;
5205  GlyphDefinition right_arrow;
5206  SelectionOptionsKit selection_options;
5207  bool manipulate_measurement; //whether we are manipulating a previously entered measurement
5208  Vector camera_direction;
5209  PortfolioKey portfolio;
5210  SegmentKey style_segment;
5211  HighlightOptionsKit highlight_options;
5212 
5213  static size_t length_measurement_index;
5214  static size_t radius_measurement_index;
5215  static size_t distance_measurement_index;
5216  static size_t angle_measurement_index;
5217 
5218  void Tag(HPS::Key & tag, const char * message, Tags tag_index);
5219  void GetUnits();
5220  void SetGlyphColor();
5221  void GetCameraDirection();
5222  void SetupConstructionSegment();
5223  void PositionLinearMeasurementGeometry(WindowPoint const & window_cursor_location, KeyPath const & event_path, LineKey & leader_line_one, LineKey & leader_line_two,
5224  LineKey & measurement_line, LineKey & line_to_cursor, Point & original_point_one, Point & original_point_two, TextKey & text, UTF8 const & text_string,
5225  Point & distance_point_one, Point & distance_point_two, SegmentKey & current_measurement_segment, Plane const & measurement_plane = Plane(), Vector const & explicit_direction = Vector());
5226  float GetModelScale(Exchange::Component const & component);
5227  void SetMaterialsOnMeasurementSegment(HPS::SegmentKey const & set_materials_here, HPS::MaterialMappingKit const & materials_to_apply);
5228  };
5229 
5283  {
5284  public:
5285  enum class MeasurementType
5286  {
5287  PointToPoint,
5288  EdgeAndRadius,
5289  FeatureToFeature,
5290  FaceAngle,
5291  };
5292 
5294 
5295  MeasurementOperator(Exchange::CADModel const & in_cad_model, MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
5296 
5298  virtual HPS::UTF8 GetName() const OVERRIDE{ return "HPS_ExchangeMeasurementOperator"; }
5299 
5300  virtual void OnViewAttached() OVERRIDE;
5301  virtual void OnViewDetached() OVERRIDE;
5302 
5307  virtual bool OnMouseDown(MouseState const & in_state) OVERRIDE;
5308 
5312  virtual bool OnMouseUp(MouseState const & in_state) OVERRIDE;
5313 
5319  virtual bool OnMouseMove(MouseState const & in_state) OVERRIDE;
5320 
5325  virtual bool OnTouchDown(TouchState const & in_state) OVERRIDE;
5326 
5330  virtual bool OnTouchUp(TouchState const & in_state) OVERRIDE;
5331 
5337  virtual bool OnTouchMove(TouchState const & in_state) OVERRIDE;
5338 
5342  virtual bool OnKeyDown(KeyboardState const & in_state) OVERRIDE;
5343 
5344  /* Sets the type of measurement to insert.
5345  * \param in_measurement_type The type of measurement to insert.*/
5346  void SetMeasurementType(MeasurementType in_measurement_type);
5347 
5350  MeasurementType GetMeasurementType();
5351 
5352  /* Whether measurable geometry should be highlighted when mousing over it
5353  * \param in_highlighting Whether measurable geometry should be highlighted when mousing over it. */
5354  void SetMouseOverHighlighting(bool in_highlighting);
5355 
5356  /* Whether measurable geometry should be highlighted when mousing over it
5357  * \param in_highlighting Whether measurable geometry should be highlighted when mousing over it.
5358  * \param in_highlight_options_kit The highlight kit used for mouse over highlights */
5359  void SetMouseOverHighlighting(bool in_highlighting, HighlightOptionsKit const & in_highlight_options_kit);
5360 
5361  /* Whether measurable geometry is highlighted when mousing over it
5362  * \return <span class='code'>true</span> if measurable geometry is highlighted on mouse over, <span class='code'>false</span> otherwise. */
5363  bool GetMouseOverHighlighting();
5364 
5365  /* Returns the highlight option kit currently used for mouse over highlighting.
5366  * \return the highlight option kit currently used for mouse over highlighting. */
5367  HighlightOptionsKit GetHighlightOptions();
5368 
5369  /* Whether a measurement is currently being inserted or edited.
5370  * \return <span class='code'>true</span> if a measurement is being inserted or manipulated, <span class='code'>false</span> otherwise. */
5371  bool IsMeasurementActive();
5372 
5373  private:
5374  enum class EdgeType //used to determine the type of edge measured when using the EdgeAndRadius measurement type
5375  {
5376  Circle,
5377  Line,
5378  Generic,
5379  };
5380 
5381  class Surface //helper class containing surfaces properties. Used for the FeatureToFeature measurement type
5382  {
5383  public:
5384  Surface();
5385 
5386  enum class SurfaceType
5387  {
5388  Plane,
5389  ConeOrCylinder,
5390  Unsupported,
5391  };
5392 
5393  SurfaceType surface_type; //the type of surface being measured
5394  Point center; //the center point of the surface
5395  Vector normal; //the center line of surfaces of type Cylinder or Cone
5396  LineKey normal_points; //the line representing the center line of surfaces of type Cylinder or Cone
5397  ComponentPath path; //the component path to this surface
5398  };
5399 
5400  //bookkeeping
5401  MeasurementType measurement_type; //the type of measurement to be inserted
5402  MeasurementType temporary_measurement_type; //the type of the measurement to be edited
5403  TouchID tracked_touch_id; //the ID of the touch to track for OnTouchMove operations
5404  TouchID current_touch_id; //the ID of the touch being processed
5405  SegmentKey current_measurement; //segment of the measurement being inserted / edited
5406  bool operator_active; //whether a measurement is in progress
5407  bool end_measurement; //whether we should end the current measurement
5408  CanvasArray canvases; //canvases related to the view where this operator is attached
5409 
5410  //measurement anchors
5411  size_t anchors; //valid for point-to-point and face-angle measurements
5412  bool anchors_in_place; //true if all the anchors have been placed
5413  Point first_click_position; //position of the first anchor
5414  Point second_click_position; //position of the second anchor
5415 
5416  //geometry for linear measurements
5417  MarkerKey anchor_one; //marker corresponding to the start of the measurement
5418  MarkerKey anchor_two; //marker corresponding to the end of the measurement
5419  LineKey distance_line; //a line representing the distance measured
5420  LineKey leader_line_one; //line connecting the first anchor point to the distance line
5421  LineKey leader_line_two; //line connecting the second anchor point to the distance line
5422  Point distance_point_one; //intersection of leader_line_one and distance_line
5423  Point distance_point_two; //intersection of leader_line_two and distance_line
5424  LineKey line_to_cursor; //line extending from distance_point_one to the cursor
5425  TextKey text; //text representing the measurement and units
5426  UTF8 text_string; //the contents of the text
5427  Vector measurement_direction; //the direction of the measurement
5428  bool use_explicit_direction; //if true, we are moving the measurement along a specific vector, called explicit_direction
5429  Vector explicit_direction; //used if use_explicit_direction is true
5430 
5431  //geometry for radius measurement
5432  MarkerKey center_marker; //marker representing the center of the circle
5433  Point circle_center; //circle center
5434  float radius; //circle radius
5435 
5436  //edge specific data
5437  LineKey edge_line; //the edge being measured
5438  double edge_length; //length of the measured edge
5439  EdgeType edge_type; //the type of edge being measured
5440 
5441  //feature-to-feature specific data
5442  Surface surface_one; //data related to first selected surface
5443  Surface surface_two; //data related to second selected surface
5444  Plane measurement_plane; //the measurement plane
5445  LineKey current_normal; //the center line of surfaces of type Cone and Cylinder
5446 
5447  //angle specific data
5448  Vector leader_line_one_direction; //the direction of the first leader line
5449  Vector leader_line_two_direction; //the direction of the second leader line
5450  Vector first_face_normal; //the normal of the first selected face
5451  Vector second_face_normal; //the normal of the second selected face
5452  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'
5453  CircularArcKey measurement_arc; //an arc representing the measured angle
5454  LineKey line_to_leader_line; //line extending from one anchor to a leader line
5455  Vector mid_point_direction;
5456 
5457  //selection kits
5458  SelectionOptionsKit point_to_point_selection;
5459  SelectionOptionsKit edge_radius_selection;
5460  SelectionOptionsKit feature_to_feature_selection;
5461  SelectionOptionsKit angle_selection;
5462 
5463  //highlighting
5464  bool highlight_on_mouse_over; //whether measurable geometry should be highlighted on mouse over
5465  HighlightOptionsKit mouse_over_highlight_options; //the options used for mouse over highlighting
5466  HighlightOptionsKit edit_measurement_highlight_options; //the options used for highlighting measurements while editing them
5467  UpdateNotifier highlight_update_notifier; //notifier used to know if the last highlight update has completed
5468  KeyPath highlighted_path; //highlighted_path
5469  bool disable_highlighting; //in some situation we temporarily disable highlighting to improve performance
5470  bool Highlight(MeasurementType in_measurement_type, WindowPoint const & in_location, WindowKey & in_window, KeyPath const & in_path);
5471 
5472  //input handling
5473  bool InputDown(WindowPoint const & in_location, WindowKey & in_window, KeyPath const & in_path, size_t number_of_clicks);
5474  bool InputMove(WindowPoint const & in_location, KeyPath const & in_path);
5475  bool InputUp(WindowKey & in_window);
5476  void ResetMeasurement();
5477 
5478  //inserting measurements
5479  void InsertPointToPointMeasurement(Point const & in_world_point);
5480  bool InsertEdgeRadiusMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_edge_key);
5481  bool InsertFeatureToFeatureMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_face_key, WindowKey & in_window);
5482  void InsertFeatureToFeatureGeometry(Point const & point_one, Point const & point_two, float distance);
5483  bool InsertAngleMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_face_key, WindowKey & in_window, SelectionResults const & in_selection_results);
5484  void InvertMeasuredAngle(WindowKey & in_window);
5485  void AdjustLineToCursor(Point const & cursor_position);
5486 
5487  //saving measurements
5488  void TagMeasurement();
5489  void TagPointToPointMeasurement();
5490  void TagEdgeMeasurement();
5491  void TagRadiusMeasurement();
5492  void TagGenericEdgeMeasurement();
5493  void TagFeatureToFeatureMeasurement();
5494  void TagAngleMeasurement();
5495 
5496  //restoring measurements
5497  void RestoreMeasurement(SegmentKey const & measurement_segment);
5498  void RestorePointToPointMeasurement(SegmentKey const & measurement_segment);
5499  void RestoreEdgeMeasurement(SegmentKey const & measurement_segment);
5500  void RestoreRadiusMeasurement(SegmentKey const & measurement_segment);
5501  void RestoreGenericEdgeMeasurement(SegmentKey const & measurement_segment);
5502  void RestoreFeatureToFeatureMeasurement(SegmentKey const & measurement_segment);
5503  void RestoreAngleMeasurement(SegmentKey const & measurement_segment);
5504  void RestoreLinearMeasurement(SegmentKey const & measurement_segment);
5505 
5506  //topology functions
5507  void GetEdgeLengthAndType(Exchange::Component const & edge_component);
5508  void GetSurfaceType(Exchange::Component const & face_component, Surface & surface);
5509  void PlaneToCenterLineDistance();
5510  void PlaneToPlaneDistance();
5511  void LineToLineDistance();
5512  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);
5513  Point ClosestPointOnTriangleToPoint(Point const & p, Point const & a, Point const & b, Point const & c);
5514  float ClosestPointSegmentSegment(Point const & p1, Point const & q1, Point const & p2, Point const & q2, Point & c1, Point & c2);
5515  bool IsPlane(Exchange::Component const & face_component);
5516  Point GetPlaneIntersection(Plane const & in_plane, KeyPath const & in_key_path, WindowPoint const & in_window_point);
5517  };
5518 
5519 private:
5521  Exchange();
5522 };
5523 
5524 }
5525 
5526 #endif
Definition: hps.h:6114
Definition: sprk_exchange.h:4146
Level
Definition: sprk_exchange.h:848
ConstructionEntities
Definition: sprk_exchange.h:1008
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3884
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:5048
An InvalidSpecificationException is thrown when a method is called with non-sensical or contradictory...
Definition: hps.h:5732
Units
Definition: sprk_exchange.h:63
Definition: sprk.h:66
Simplification
Definition: sprk_exchange.h:2889
Definition: sprk.h:100
Definition: sprk_exchange.h:598
Version
Definition: sprk_exchange.h:1029
Definition: sprk_exchange.h:3161
Definition: sprk_exchange.h:858
Definition: sprk_exchange.h:697
virtual HPS::UTF8 GetName() const OVERRIDE
Definition: sprk_exchange.h:5067
HPS::Type ObjectType() const
Definition: sprk_exchange.h:679
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4803
SurfaceType
Definition: sprk_exchange.h:780
Definition: hps.h:1714
Format
Definition: sprk_exchange.h:946
HPS::Type ObjectType() const
Definition: sprk_exchange.h:725
Definition: sprk_exchange.h:4787
Definition: sprk.h:234
std::vector< KeyPath, Allocator< KeyPath > > KeyPathArray
Array of type HPS::KeyPath.
Definition: hps.h:6578
std::vector< byte, Allocator< byte > > ByteArray
Array of type HPS::byte.
Definition: hps.h:6554
Definition: hps.h:47139
Format
Definition: sprk_exchange.h:1129
Definition: hps.h:7612
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4162
std::vector< bool, Allocator< bool > > BoolArray
Array of type bool.
Definition: hps.h:6548
Type
Definition: sprk_exchange.h:839
Definition: hps.h:15878
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3707
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:5298
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4017
MeasurementInsertedEvent(Event const &in_event)
Definition: sprk_exchange.h:5125
HPS::Type ObjectType() const
Definition: sprk_exchange.h:132
Definition: sprk_exchange.h:1369
Definition: sprk_exchange.h:238
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4521
HPS::Type ObjectType() const
Definition: sprk_exchange.h:323
Definition: sprk_exchange.h:3868
Merging
Definition: sprk_exchange.h:2898
HPS::Type ObjectType() const
Definition: sprk_exchange.h:2933
Field
Definition: sprk_exchange.h:936
Definition: hps.h:47038
Definition: hps.h:40747
HPS::Type ObjectType() const
Definition: sprk_exchange.h:1078
Definition: sprk_exchange.h:3590
Definition: sprk_exchange.h:2911
Limit
Definition: sprk_exchange.h:863
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4318
Definition: hps.h:4424
TessellationLevel
Definition: sprk_exchange.h:910
Definition: sprk_exchange.h:834
Definition: sprk_exchange.h:4505
Definition: sprk_exchange.h:111
Definition: sprk_exchange.h:931
Definition: hps.h:4363
Definition: hps.h:6985
Definition: hps.h:46530
Definition: sprk_exchange.h:409
UnloadMode
Definition: sprk_exchange.h:80
Definition: hps.h:42704
Definition: hps.h:46926
Definition: sprk_dwg.h:43
AnnotationCaptureFitting
Definition: sprk_exchange.h:827
Definition: sprk_exchange.h:4687
Definition: sprk_exchange.h:896
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3606
Definition: hps.h:15271
Event * Clone() const
Definition: sprk_exchange.h:5187
std::vector< int, Allocator< int > > IntArray
Array of type int.
Definition: hps.h:6534
intptr_t GetChannel() const
Definition: hps.h:6231
Definition: sprk_exchange.h:1024
SessionColor
Definition: sprk_exchange.h:983
Definition: sprk.h:1724
Definition: hps.h:47245
LoadStatus
Definition: sprk_exchange.h:95
Definition: hps.h:43827
Definition: hps.h:46049
CurveType
Definition: sprk_exchange.h:803
Definition: sprk_exchange.h:498
Definition: hps.h:6198
Definition: hps.h:13532
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4920
std::vector< UTF8, Allocator< UTF8 > > UTF8Array
Array of type HPS::UTF8.
Definition: hps.h:6546
Definition: sprk_exchange.h:5282
Definition: sprk.h:473
HPS::Type ObjectType() const
Definition: sprk_exchange.h:1615
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:3444
Definition: sprk_exchange.h:3691
HPS::Type ObjectType() const
Definition: sprk_exchange.h:1391
MeasurementDeletedEvent(Event const &in_event)
Definition: sprk_exchange.h:5171
Definition: sprk.h:2363
FamilyTable
Definition: sprk_exchange.h:996
Content
Definition: sprk_exchange.h:901
Definition: sprk_exchange.h:1593
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3183
HPS::Type ObjectType() const
Definition: sprk_exchange.h:626
Definition: sprk.h:2462
static MouseButtons ButtonLeft()
Definition: hps.h:46648
Definition: hps.h:7531
Definition: sprk_exchange.h:978
AccurateEdges
Definition: sprk_exchange.h:2880
Event * Clone() const
Definition: sprk_exchange.h:5141
HPS::Type ObjectType() const
Definition: sprk_exchange.h:480
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4703
Definition: hps.h:9189
HPS::Type ObjectType() const
Definition: sprk_exchange.h:205
Definition: sprk_exchange.h:651
Definition: hps.h:23666
Healing
Definition: sprk_exchange.h:2871
Definition: sprk.h:2548
Definition: hps.h:30067
ImportMode
Definition: sprk_exchange.h:768
Definition: sprk_exchange.h:1041
Definition: hps.h:518
Definition: sprk.h:1093
Definition: sprk_exchange.h:2866
static Model CreateModel(char const *in_name="")
Definition: sprk_exchange.h:4001
Definition: sprk_exchange.h:173
Definition: hps.h:40244
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3460
Version
Definition: sprk_exchange.h:919
Definition: sprk_exchange.h:4904
HPS::Type ObjectType() const
Definition: sprk_exchange.h:566
Definition: hps.h:41357
Definition: sprk_exchange.h:4302