HUtility.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 // HUtility.h : interface of the HUtility class
11 // Set of utility methods
12 // All methods are public and static
13 
14 
15 #ifndef _HUTILITY_H
16 #define _HUTILITY_H
17 
18 #ifdef H_PACK_8
19 #pragma pack(push)
20 #pragma pack(8)
21 #endif
22 
23 
24 #include "HTools.h"
25 #include "hic_types.h"
26 
27 #include <limits>
28 #include <cmath>
29 
30 class HBaseView;
32 class HSmartSelItem;
33 class HBaseModel;
34 
35 class HShellObject;
36 
37 
38 enum AbsoluteWindowType
39 {
40  RelativeLeft,
41  RelativeRight,
42  RelativeTop,
43  RelativeBottom,
44  NotRelative
45 };
46 
48 {
49 public:
51  {
52  nindex = -1;
53  tcindex = -1;
54  nextindex = -1;
55  }
56  int nindex;
57  int nextindex;
58  int tcindex;
59 };
60 
61 
62 class MVO_API ShellToRegionMapper
63 {
64 public:
66  void AddRegion(HC_KEY originalshell, HC_KEY newshell, int regionnum, bool check = true);
67  HC_KEY GetOriginalShell(HC_KEY newshell, int regionnum);
68  int GetRegionsFromOriginalShell(HC_KEY originalshell, HC_KEY **newshells, int &regionnum);
69  void BuildSegmentTreeRecursive(HC_KEY okey, HC_KEY nkey);
70  void MapSegmentTree(HC_KEY modelkey);
71  void AddSegmentMapping(HC_KEY originalshell, HC_KEY segmentkey);
72 
73  struct vhash_s * m_RegionToShellHash;
74  struct vhash_s * m_ShellToRegionHash;
75  struct vhash_s * m_ShellToSegmentHash;
76 
77 };
78 
79 
80 
81 
82 
84 
87 class MVO_API HShellEdge {
88 public:
93  HShellEdge(int iFirst = 0, int iSecond = 0){
94  Set(iFirst, iSecond);
95  };
97  int GetFirst() const { return m_iFirst; };
99  int GetSecond() const { return m_iSecond; };
104  void Set(int first, int second) {
105  /* first should always be < second to eliminate ambiguity. */
106  if(first < second){
107  m_iFirst = first;
108  m_iSecond = second;
109  } else {
110  m_iFirst = second;
111  m_iSecond = first;
112  }
113  };
114 
115  bool operator<(HShellEdge const & rhs) const {
116  if(m_iFirst != rhs.m_iFirst)
117  return m_iFirst < rhs.m_iFirst;
118  return m_iSecond < rhs.m_iSecond;
119  }
120 
121 private:
122  int m_iFirst;
123  int m_iSecond;
124 };
125 
127 
130 class MVO_API HShellFace{
131 public:
136  HShellFace(HShellObject const * pShell, int const iFaceIndex);
137 
139  int GetPointCount() const ;
140 
142  int GetEdgeCount() const ;
147  HShellEdge const GetEdge(int const iEdgeIndex) const;
151  void OpenEdge(int const iEdgeIndex) const;
155  void CloseEdge() const;
156 
157 private:
158  HShellObject const * m_pShell;
159  int m_iFaceIndex;
160  int m_iPointCount;
161 };
162 
164 
167 class MVO_API HShellRegion{
168 public:
173  HShellRegion(HShellObject const * pShell, int const iRegionIndex);
174  ~HShellRegion(){
175  delete [] m_pRegionFlist;
176  }
179  int GetFaceCount() const;
184  HShellFace const GetFace(int index) const;
185 
186  //void Open() const;
187  //void Close() const;
188 private:
189  HShellObject const * m_pShell;
190  int m_iRegionIndex;
191 
192  int m_iRegionFlistLength;
193  int *m_pRegionFlist;
194 };
195 
196 
198 
201 class MVO_API HShellObject {
202 public:
206  HShellObject(HC_KEY kShellKey);
207  HShellObject(HShellObject const & oShellObj);
208  ~HShellObject();
209 
214  HShellRegion const GetRegion(int const index) const;
215 
217  int GetFaceCount() const;
222  int GetFaceFlistIndex(int index) const;
223 
224  //void Open() const;
225  //void Close() const;
226 
228  HC_KEY GetKey() const ;
230  int GetFlistLen() const ;
232  int const * GetFlist() const ;
235  void GetFlist (int flist[]) const;
236 
237 private:
238  int m_iFlistLen;
239  int * m_pFlist;
240  mutable int * m_pFaceIndexes;
241 
242  HC_KEY m_kShellKey;
243 };
244 
245 
247 
250 class MVO_API HShell {
251 public:
252  HShell()
253  :point_list_len(0),
254  point_list(),
255  normal_list(),
256  face_list_len(0),
257  face_list(0),
258  face_count(0),
259  region_count(0),
260  region_list(0)
261  {}
262  ~HShell()
263  {
264  /* No need to check for null pointers. delete already does that. */
265  delete [] point_list;
266  delete [] normal_list;
267  delete [] face_list;
268  delete [] region_list;
269  }
273 
275  int *face_list;
277 
279  int *region_list;
280 };
281 
283 
287 class MVO_API HShellWrapper {
288 
289 public:
294  HShellWrapper(HC_KEY key) {
295  m_Points = 0;
296  m_Flist = 0;
297  m_VParams = 0;
298  m_VNormals = 0;
299  m_VColors = 0;
300  m_faceregion = 0;
301  m_totalnumfaceslen = 0;
302  m_numfaceslen = 0;
303  m_FNArray = 0;
304  m_faceindirect = 0;
305  Set(key);
306  }
311  m_Key = INVALID_KEY;
312  m_Points = 0;
313  m_Flist = 0;
314  m_VParams = 0;
315  m_VNormals = 0;
316  m_VColors = 0;
317  m_flen = 0;
318  m_plen = 0;
319  m_totalplen = 0;
320  m_totalflen = 0;
321  m_faceregion = 0;
322  m_totalnumfaceslen = 0;
323  m_numfaceslen = 0;
324  m_FNArray = 0;
325  m_faceindirect = 0;
326  }
327  ~HShellWrapper();
328 
339  HC_KEY Insert(int plen, HPoint points[], int flen, int flist[], HC_KEY insertkey = INVALID_KEY);
347  HC_KEY Show(int *plen, HPoint **points, int *flen, int **flist);
351  HC_KEY GetKey() { return m_Key; }
355  void TransformPoints(float matrix[]);
356 
361  HC_KEY Optimize(char *options);
367  HC_KEY Optimize2(char *options);
368 
369  void MakePolygon(int facelen, int face[], HPoint points[]);
370 
371 
374  void OpenOwnerSegment();
375 
378  void BeginFaceIteration();
379 
382  void EndFaceIteration() { ; };
383  int GetFace(int facenum, int **face);
388  int NextFace(int **face);
389 
395  void CalculateFaceCenter(int face[], int flen, HPoint *mid);
402  void AddPoints(HPoint points[], int pnum, HPoint param[] = 0, HPoint normals[] = 0, bool AddImmediately= false);
409  void AddFace(int face[], int fnum, int regionnum, HPoint points[], HPoint normals[] = 0, bool AddImediately= false);
416  void AddFaceDirect(int face[], int fnum, bool reverse = false, bool AddImmediatly= false);
423  void AddFace(HPoint points[], int fnum, bool AddImmediatly= false);
428  void Set(HC_KEY key);
435  void Regenerate(HC_KEY newowner = INVALID_KEY, bool makeSegment = true, bool regenerate = false);
440  void GrowArrays(int fnum);
446  void GrowPointArray(int fnum, bool gorwvparams = false, bool grownormals = false);
447 
448  void GrowPointArray2(int fnum, bool growparamarray = false, bool grownormalarray = false, bool growfnarray = false, bool growcolorarray = false);
449  void AddNextFaceWithDistinctNormals(HPoint const * points, HPoint const * normals, int const * face1, int const * face2, int fnum);
450  void AddNextFaceWithDistinctNormalsAndTexture(HPoint const * points, HPoint const * normals, HPoint const * texcor,int const * face1, int const *face2, int const *face3, int fnum);
451  void AddNextFaceWithDistinctNormalsAndColor(HPoint const *points, HPoint const *normals,int const *face1, int const *face2, HPoint *face3, int fnum);
452 
453 
454  void BeginAddFaces(int pnum);
455  void EndAddFaces();
456 
461  void GrowFaceArray(int fnum);
462 
464  void SubdivideOneQuadFace(int face[], HShellWrapper &wrapper, bool generateIsolines, int *facecolorlist, int &fclnum);
465 
467  void SubdivideOneQuadFace2(int face[]);
472  void SubdivideQuadFaces(bool GenerateIsolines);
473 
477  void SetVertexColors(HPoint *color);
481  void ShowVertexColors(HPoint *color);
486  void SetVertexColors(float *findex);
490  void ShowVertexColors(float *color);
496  void MakeLod(int lodnum, int percent);
502  void FindExtents(HPoint &center, HPoint &min, HPoint &max);
503  void ReplaceWithParameters(int plen, HPoint points[], int flen, int flist[], HPoint normals[] = 0, float params[] = 0, int paranum = 3, HPoint vcolors[] = 0, bool emptyshell = false);
504  void ReplaceWithParameters(int plen, HPoint points[], int flen, int flist[], HPoint normals[], float params[], int paranum, bool emptyshell);
505  void Replace(int plen, HPoint points[], int flen, int flist[], HPoint normals[] = 0, bool emptyshell = false);
506 
507  void SetFaceRegion(int regionnum);
508 
509  void SetEmptyShell(HC_KEY segmentkey, bool MakeSegment);
510 
511 
512  int m_plen;
513  int m_flen;
514  HPoint *m_Points;//<! The list of pointst that define the shell.
515  HPoint *m_VParams;
516  HPoint *m_VColors;
517  HPoint *m_VNormals;
518  int *m_Flist;
519  HC_KEY m_Key;
520 
527  int m_totalnumfaceslen;
528  int m_numfaceslen;
529  int *m_faceregion;
530  int *m_faceindirect;
531  FaceWithNormalInfo *m_FNArray;
532 
533 };
534 
535 
537 
540 class MVO_API HCamera {
541 public:
542  bool valid;
546  float field_width;
547  float field_height;
548  char projection[128];
549 
550  HCamera () {
551  projection[0] = '\0';
552  valid = false;
553  }
554 
556  inline void InvalidateCamera() { projection[0]='\0'; valid = false; }
557 
561  bool CameraDifferent(HCamera &cam);
562 
566  bool CameraDifferentByAngle(HCamera &cam);
567 
568 
571  void GetFromView(HBaseView * view);
572 
574  void Show();
575 
577  void Set() const;
578 };
579 
580 
582 
585 class MVO_API HBSurfVertex
586 {
587 public:
588  double x;
589  double y;
590  double z;
591  double w;
592 
595  inline void Set(double X, double Y, double Z, double W) { x=X, y=Y, z=Z, w=W; }
596 };
597 
599 
603 class MVO_API HPolyline
604 {
605 public:
609 };
610 
612 
616 class MVO_API HShellVertexData
617 {
618 public:
619  /* Constructor initializes this object to an invalid state. */
620  HShellVertexData():m_VertexCount(0), m_pFIndexArraySize(0), m_pFIndexArray(0), m_Key(INVALID_KEY){
621  m_sType[0] = '\0';
622  }
623 
624  /* Destructor free up the resources this object is using. */
625  ~HShellVertexData(){
626  ResetMyself();
627  }
628 
629  /* Sets the key and fills in the members with the correct data for this shell. */
630  void SetKey(HC_KEY const key);
631 
632  /* Return a const string for the type of shell. */
633  const char * GetType() const {
634  return m_sType;
635  }
636 
637  /* Returns the vertex count for this shell. */
638  int GetVertexCount() const {
639  return m_VertexCount;
640  }
641 
642  /* Return the key for the shell */
643  HC_KEY GetKey() const {
644  return m_Key;
645  }
646 
647  /* Return the size the findex array */
648  int GetFIndexDataSize() const {
649  return m_pFIndexArraySize;
650  }
651 
652  /* Returns a const array for the findex values in this shell. */
653  float const * GetFIndexData() const {
654  return m_pFIndexArray;
655  }
656 
657  /* Returns a const array (as an argument) for the findex values in this shell.
658  Note that the array must be of the appropriate size, e.g., via a call to GetFIndexDataSize. */
659  void GetFIndexData(float data[]) const;
660 
661  void SetFIndexData(int const size, float const data[]);
662 
663 private:
664  void ResetMyself();
665 
666  int m_VertexCount;
667  int m_pFIndexArraySize;
668  float *m_pFIndexArray;
669  HC_KEY m_Key;
670  char m_sType[32];
671 };
672 
673 
675 
677 typedef struct
678 {
679  HC_KEY *patharray;
680  int len;
682 
683 
684 enum HWindowCorner
685 {
686  TopLeft,
687  BottomLeft,
688  BottomRight,
689  TopRight
690 };
691 
692 
693 
694 
695 
696 
697 
699 
717 class MVO_API HUserOptions
718 {
719 public:
720 
721  char * m_data;
722  int m_length;
723  bool m_valid;
724 
726  HUserOptions();
727 
729  HUserOptions(const HUserOptions& in_data);
730 
731 
733  ~HUserOptions();
734 
735 
739  bool IsValid();
740 
746  const char * Show_User_Options();
747 
753  const char * Show_One_Net_User_Option(const char * which);
754 
760  const char * Show_One_User_Option(const char * which);
761 
767  const char * Show_Net_User_Options();
768 
769 
770 private:
771 
772  void clear() {
773  delete [] m_data;
774  m_data = 0;
775  m_length = 0;
776  };
777 
778 };
779 
780 
781 
783 
786 class MVO_API HUtility
787 {
788 public:
789 #undef PI
790  static const float PI;
791 
792  enum{X, Y, Z, W};
793  enum{XY, XZ, YZ};
794 
795  static const float EH_Epsilon;
796 
797 
804  static void Order(HPoint* one, HPoint* two);
805 
812  static void Find_Relative_Path(HC_KEY from_seg_key, HC_KEY to_seg_key, char * path);
813 
817  static float GetTime();
818 
819 
824  static void ClampPointToWindow (HPoint * point);
825 
832  static HC_KEY InsertBox (HPoint const * max, HPoint const * min);
833 
841  static HC_KEY InsertWireframeBox (HPoint * max, HPoint * min);
842 
849  static void GenerateCuboidPoints (HPoint const * max, HPoint const * min, HPoint * points);
850 
862  static HC_KEY InsertRectangle (const char * seg, float x0, float y0, float x1, float y1, float z = 0.0f, bool fill = false);
863 
864 
879  static void InsertArrow(float stick_length, float tip_length, float stick_radius, float arrow_radius, const char *text, const char *stick_color, const char *tip_color, int num_sides = 6, float tip_falloff = 0.05, bool reverse = true);
880 
887  static void ComputeDoublePrecisionCrossProduct(double * vector1, double * vector2, double * up);
888 
895  static double ComputeDoublePrecisionDotProduct(double * vector1, double * vector2);
896 
902  static double ComputeDoublePrecisionVectorLength(double * vector1);
903 
910  static void GetViewplaneVectors(HC_KEY segment_key, double * view, double * up);
911 
916  static void NormalizeDoublePrecisionVector(double* vector1);
917 
925  static bool PointsEqual(HPoint * point1, HPoint * point2);
926 
938  static bool CreateAxisCircle (HPoint const & center, float radius, int axis, bool convert = true);
939 
940 
947  static void RotateToVector(HPoint start, HPoint end, bool doTranslation = true);
948 
964  static void SmoothTransition(const HPoint &co, const HPoint &to, const HPoint &uo, float fieldwidtho, float fieldheighto, const HPoint &cn, const HPoint &tn, const HPoint &un, float fieldwidthn, float fieldheightn, HBaseView *view);
965 
973  static void SmoothTransition(HCamera old_camera, const HCamera &new_camera, HBaseView *view);
974 
981  static bool CamerasEqual(const HCamera &camera1, const HCamera &camera2);
982 
990  static void ComputeVectorToVectorRotationMatrix(float matrix[],HPoint v1,HPoint v2);
991 
1000  static bool ExtractRGB(char *text,float &r, float &g, float &b);
1001 
1012  static void TransitionQuaternion(float quat_old[], float quat_new[], float t, float qt[]);
1013 
1019  static void MatrixToQuaternion(float matrix[], float quaternion[]);
1020 
1026  static void QuaternionToMatrix(float quaternion[], float matrix[]);
1027 
1036  static void SmoothQuaternionTransition(HBaseView *m_pView, char *old_seg, char *new_seg, int num_of_transitions);
1037 
1045  static void SmoothMatrixTransition(HBaseView *m_pView, HC_KEY seg_key, float new_matrix[]);
1046 
1056  static void MultiSmoothTransitions(HBaseView *m_pView, int num_keys, HC_KEY *seg_key, float new_matrix[], HCamera *new_camera = 0);
1057 
1063  static HPoint GetCentroid(HC_KEY seg_key);
1064 
1071  static HPoint GetTransformedCentroid(HC_KEY seg_key, float matrix[] = 0);
1072 
1080  static void URIencode(const char * in_string, MVO_POINTER_SIZED_UINT n, char * out_buffer);
1088  static void URIdecode(const char * in_string, char * out_buffer, MVO_POINTER_SIZED_UINT * n);
1089 
1098  static void GetCameraFromMatrix(float matrix[], HPoint *target, HPoint *position, HPoint *up_vector, HPoint *translation);
1099 
1108  static void GetMatrixFromCamera(HPoint target, HPoint position, HPoint up_vector, HPoint translation, float matrix[]);
1109 
1110 
1144  static void GetCameraFromGLFrustum(double const left, double const right, double const bottom , double const top, double const near_z, double const far_z, bool const perspective,
1145  HPoint &pos, HPoint &target, HPoint &up, char * projection, double &width, double &height, double &near_limit );
1146 
1154  static bool PushAttribute(const char *attName);
1155 
1164  static void PushAttribute(const char *attName, const char *attText);
1165 
1173  static bool PopAttribute(const char *attName);
1174 
1185  static bool ModifyPushedAttribute(const char *attName, const char *newStyle);
1186 
1193  static bool ShowPushedAttribute(const char *attName, HUserOptions& attText);
1194 
1207  static void Recursive_Merge_Shells( HShell *total_info, HShell *max_info, bool do_recurse, bool delete_orig_shells = false, bool insert_null_lods = false );
1208 
1215  static HC_KEY Merge_Shells( bool do_recurse, bool delete_orig_shells = false , bool optimize_shell = true, bool generate_regions = false);
1216 
1224  static HC_KEY Merge_Shells_Generate_Regions( int num_shells, HC_KEY * shell_keys, bool delete_orig_shells = false );
1225 
1235  static void Generate_LODs( bool do_recurse = true, bool delete_orig_shells = false, bool insert_null_lods = false, int n_lod_levels = 2, float reduction_ratio = 0.20 );
1236 
1244  static bool Segment_Shell_Allocate( HShell *total_info, HShell *max_info, bool do_recurse );
1245 
1253  static void Shell_Search( HShell *total_info, HShell *max_info, bool do_recurse );
1254 
1255 
1256 
1267  static void OptimizeSegmentTree(HC_KEY old_seg_key, HC_KEY *new_seg_key, bool transform_shells = true, bool merge_shells = true, bool create_shell_regions = false);
1268 
1269 
1278  static void CountShellData(HC_KEY shell_key, int * faces, int * vertices, int * triangles, int * tristrips = 0);
1279 
1286  static void FindFileNameExtension(const char * filename_in, char * ext_out, int size = -1);
1287 
1294  static void FindFileNameExtension(__wchar_t const * const filename_in, __wchar_t * ext_out, int size = -1);
1295 #ifdef H_USHORT_OVERLOAD
1296  static void FindFileNameExtension(unsigned short const * const filename_in, unsigned short * ext_out, int size = -1){
1297  FindFileNameExtension((wchar_t const * const)filename_in, (wchar_t*)ext_out, size);
1298  }
1299 #endif
1300 
1305  static void FindUnicodeFileNameExtension(const unsigned short * filename_in, char * ext_out);
1306 
1314  static void FindFileNameAndDirectory(const char * filename_in, char * dir_out, char * filename_out);
1322  static void FindFileNameAndDirectory(__wchar_t const * filename_in, __wchar_t * dir_out, __wchar_t * filename_out);
1323 
1334  static const char* extra_pointer_format();
1338  static HC_KEY CreateScaleIndependentSegment(const char *segname, bool SetCallback = true);
1339 
1343  static HC_KEY GetScaleIndependentGeomSegmentKey(HC_KEY segkey);
1344 
1348  static void SetScaleIndependentGeomPosition(HC_KEY segkey, float x, float y, float z);
1349 
1353  static void GetScaleIndependentGeomPosition(HC_KEY segkey, float &x, float &y, float &z);
1354 
1358  static void RegisterCallbacks();
1359 
1366  static bool IsModelKey(HC_KEY modelkey, HC_KEY objectkey);
1367 
1375  static HC_KEY UserOptionExists(HC_KEY key, const char *attrib, char *result);
1376 
1393  static void InsertRotatedArrow(float stick_length, float tip_length, float stick_radius, float tip_radius, float distance, int adelta, float rotang, const char *stick_color, const char *tip_color, int num_sides, float tip_falloff, bool reverse);
1394 
1404  static int CalculateKeyPath(HC_KEY startkey, HBaseView *view, HC_KEY *keyarray, int maxarray);
1405 
1410  static bool SegmentExists(const char *segment);
1411 
1414  static void UnsetAttributes();
1415 
1423  static int IsChildOf(HC_KEY owner, HC_KEY child, HC_KEY klist[] = 0);
1424 
1430  static bool IsIdentityMatrix(float matrix[]);
1431 
1438  static void ComputeShellNormal(HC_KEY skey, HPoint &tnormal);
1439 
1449  static HC_KEY SelectUnderCursor(HBaseView *view, float x, float y, bool doSelection = true, bool DeSelect = false);
1450 
1451 
1462  static HC_KEY SmartSelectUnderCursor(HBaseView *view, float x, float y, bool doSelection = true, bool DeSelect = false);
1463 
1464 
1471  static bool ShowOneHeuristic(const char *type, char *res = 0);
1478  static bool ShowOneRenderingOption(const char *type, char *res = 0);
1479 
1489  static float EaseInEaseOut(float t, float a, float b, float c);
1490 
1495  static void UnwindIncludes(HC_KEY &key);
1496 
1503  static void UnwindIncludes(HC_KEY &newkey, HC_KEY *keys, int count);
1504 
1505 
1512  static bool SafeSetUserOption(const char * opt);
1513 
1520  static bool SafeShowUserOption(char * opt);
1521 
1522 
1527  static void ProjectShell(HC_KEY shellkey);
1528 
1535  static HC_KEY MergeShells(HC_KEY shell1, HC_KEY shell2);
1536 
1542  static void ShowModellingMatrix(float *segment_modelling_matrix);
1543 
1550  static void ConvertLocalPixelsToLocalWindow(HBaseView * view, HPoint *in_system , HPoint *out_system = 0);
1551 
1552 
1559  static HC_KEY GrabSegment(HC_KEY key);
1560 
1565 # define MakeSegment(key) GrabSegment(key)
1566 
1572  static void RenameSegment(HC_KEY segkey, const char *newname);
1573 
1574 
1585  static void InterpolateNormalAlongEdge(HPoint &p1, HPoint &n1, HPoint &p2, HPoint &n2, HPoint &p3, HPoint &n3);
1586 
1592  static void ShowNormals(HC_KEY shellkey, float normallength);
1593 
1599  static bool IsSegmentKey(HC_KEY key);
1600 
1608  static int FindContents(HC_KEY &key, bool original = false);
1609 
1616  static int CalculateMajorAxis(HBaseView *view);
1617 
1618 
1626  static HC_KEY FindOneObject(const char *type, bool l = 0);
1632  static void CloseAllSegments(HC_KEY endkey = INVALID_KEY);
1633 
1638  static void ReadjustTarget(HBaseView *view);
1639 
1644  static bool GetAllowAnimation(HC_KEY key);
1645 
1648  static void SuppressAnimation();
1649 
1657  static int FindFaceByIndex(int findex, int *flist, int flen);
1658 
1665  static bool ShowOneUserOption(const char *option, char *res);
1666 
1672  static HC_KEY GetNextRenumberedKey(HBaseView *view);
1673 
1679  static void NameSegments(HC_KEY &key, HBaseView *view);
1680 
1686  static void MoveToTemp(HC_KEY movekey, HC_KEY tempkey);
1687 
1698  static void ShowContentsWithPath( const char * entitytypes, struct vlist_s **ret_pathlist, bool storePath = false, bool includeIncludes = true, bool filterIncludes = true);
1699 
1700 
1706  static int ustrlen(unsigned short *text);
1707 
1717  static bool RLECompress(int const in_len,
1718  unsigned char const * const in_buf,
1719  int * out_len,
1720  unsigned char * const out_buf);
1721 
1731  static bool ZlibCompress(int const in_len,
1732  unsigned char const * const in_buf,
1733  int & out_len,
1734  unsigned char * const out_buf);
1735 
1745  static bool ZlibDecompress(int const in_len,
1746  unsigned char const * const in_buf,
1747  int & out_len,
1748  unsigned char * const out_buf);
1754  static unsigned short *uconvert(const char *text);
1755 
1766  static bool BuildIncludePath(HC_KEY objectkey, const HC_KEY *includelist, int ilength, HC_KEY *fullpath, int *fplength, HC_KEY matchkey = INVALID_KEY);
1767 
1774  static void BuildIncludePathFromSelection(HSmartSelItem *sitem, int &plen, HC_KEY *fullpath);
1775 
1776 
1785  static void MakeViewSnapshot(HBaseView * view, int width, int height, char ** data);
1786 
1792  static void MakeViewSnapshot(HBaseView * view, HC_KEY image_key);
1793 
1802  static int ConstrainToVector( const float matrix_in[], const HVector &vector, float matrix_out[]);
1803 
1811  static void Camera_To_Transform (HCamera *camera , float *pos, float projection_matrix[], float complete_matrix[]);
1822  static void LocalPixelsToWorld(HCamera *camera, bool righthanded, float xres, float yres, int xwpix, int ywpix, float result[]);
1829  static float ComputeAngleBetweenVector(HPoint p1, HPoint p2);
1830 
1831 
1837  static int strlen16( const unsigned short *p16);
1838 
1847  static void CalculateBoundingInfo(HC_KEY startkey, HPoint &min, HPoint &max, HPoint &delta, HPoint &mid);
1848 
1858  static long ClipPolygonAgainstPlane(long vertexCount, const HPoint vertex[],
1859  const float plane[], HPoint result[], bool *noCut = 0);
1860 
1867  static HFileOutputResult TwoPassPrint(const char *driver, HOutputHandlerOptions *options);
1868 
1876  static HC_KEY OpenSegmentFromKey(HC_KEY key, char *segment);
1877 
1878 
1890  static bool IsPointInsideAllEdges( const float *pt,const float points1[],
1891  int len, const int face1[], const float plane1[], float fudge );
1899  static void IntersectionLinePlane(HPoint *p1, HPoint *p2, HPlane *p, HPoint *res);
1900 
1906  static void DeleteManipulators(HC_KEY key);
1907 
1908 
1923  static void MergePointsIntoShell(int num_shell_points, HPoint plist1[], int num_shell_facelist, int flist1[],
1924  int num_merge_points, HPoint merge_points[], HPoint merge_vectors[],
1925  float tolerance, bool AddExtraPoints, int newpoints[], int *newpointslen);
1926 
1927 
1942  static void SubdivideShells(HC_KEY sskey, HC_KEY startkey, HC_KEY newkey, int numx, int numy, int numz, ShellToRegionMapper *mapper = 0, bool DoCut = true, bool DeleteOriginalShells = false, bool breakShells = false);
1943 
1945  static void MergePolylines();
1946  static void CreateZebraStripeTexture(int width, int height, int stripwidth, bool horizontal, HPixelRGB colorstripes, HPixelRGB colorbackground);
1947 
1955  static void ascii_to_unicode(char const *ascii, unsigned short *unicode);
1956 
1964  static void unicode_to_ascii(unsigned short const *unicode, char *ascii);
1965 
1974  static void BatchRead(HBaseModel * model, const char * directory, const char * extension);
1975 
1983  static void AdjustPositionToPlane(HBaseView * view, HPoint &position, HPoint point_in_plane);
1984 
1993  static void CalculateCornerImagePosition(HBaseView *view, int iwidth, int iheight, HWindowCorner corner, float &posx, float &posy);
1994  static void OptimizeModelByGrid(HBaseView *view, ShellToRegionMapper *mapper);
1995  static void DecipherTextureString(char *texdef, char *Source, bool *DownSampling = 0, bool *DownSamplingSet = 0, char *ParameterizationSource = 0,
1996  char *InterpolationFilter = 0, char *DecimationFilter = 0, char *Layout = 0, char *Tiling = 0, bool *ValueScaleSet = 0,
1997  bool *ValueScale = 0, float *ValueScaleMin =0, float *ValueScaleMax = 0, char *BlendingMode = 0);
1998 
2003  static inline bool IsSafeForSinglePrecision(double element, bool check_roundoff = false) {
2004  if (std::abs(element) > (std::numeric_limits<float>::max)())
2005  return false;
2006  if (check_roundoff) {
2007  if (std::abs(element - static_cast<float>(element)) > std::numeric_limits<float>::epsilon() * 0.001 * std::abs(element))
2008  return false;
2009  }
2010  return true;
2011  }
2012 
2018  static inline bool IsSafeForSinglePrecision(int element_count, double const * elements, bool check_roundoff = false) {
2019  while (element_count-- > 0)
2020  if (!IsSafeForSinglePrecision(*elements++, check_roundoff))
2021  return false;
2022  return true;
2023  }
2024 
2025 
2026 private:
2027  static void scale_segment (HIC_Rendition *rendition,HIC_Segment_Info * geo3);
2028  static void activity_change (HIC_Segment *seg, int old_activity, int new_activity);
2029  static bool RestoreAttributeFromOption(const char *attName, HUserOptions& attText);
2030  static void ReplaceCharacter(char *text, char orig, char target);
2031  static bool SetAttribute(const char *attName, const char *attText);
2032  static bool ShowAttribute(const char *attName, char *attText);
2033  static void ShowContentsWithPathAddEntity(HC_KEY key, struct vlist_s *pathlist, int level, HC_KEY *patharray, bool storePath);
2034  static void ShowContentsWithPathRecursive(HC_KEY key, const char *entitytypes, struct vlist_s *pathlist, HC_KEY *patharray, int level, bool storePath, bool includeIncludes, bool filterIncludes);
2035  static void SubdivideOneShell(HShellWrapper &myshell, int numx, int numy, int numz, HPoint &totalmin,
2036  HPoint &totaldeltadiv, HShellWrapper *shellmatrix, HShellWrapper &leftover, float boxdiagonallength, bool DoCut, int regionnum, ShellToRegionMapper *mapper, HC_KEY newkey);
2037 
2038 
2039 };
2040 
2041 
2042 class MVO_API HQualifiedKey
2043 {
2044 public:
2045  HQualifiedKey(HC_KEY key, HC_KEY includelist[], int includelistlength)
2046  {
2047  m_Key = key;
2048  m_pIncludeList = 0;
2049  m_pIncludeList = new HC_KEY[includelistlength];
2050  for (int i = 0; i < includelistlength; i++)
2051  m_pIncludeList[i] = includelist[i];
2052  m_IncludeListLength = includelistlength;
2053  }
2054  ~HQualifiedKey()
2055  {
2056  delete [] m_pIncludeList;
2057  }
2058 
2059  long MakeHashKey()
2060  {
2061  return MakeHashKey(m_Key, m_IncludeListLength,m_pIncludeList);
2062  }
2063 
2064  static long MakeHashKey(HC_KEY key, int includelength, HC_KEY includes[])
2065  {
2066  long hashkey = static_cast<long>(key);
2067  for (int i = 0; i < includelength; i++)
2068  {
2069  hashkey += static_cast<long>(includes[i]);
2070  }
2071  return hashkey;
2072  }
2073 
2074  HC_KEY m_Key;
2075  HC_KEY * m_pIncludeList;
2076  int m_IncludeListLength;
2077 };
2078 
2079 
2080 
2081 
2082 class MVO_API HMergeShellFace
2083 {
2084 
2085 public:
2086  HMergeShellFace()
2087  {
2088  m_pChildFaces = 0;
2089  m_ChildFaceNum = 0;
2090  }
2091  ~HMergeShellFace()
2092  {
2093  if (m_pChildFaces)
2094  delete [] m_pChildFaces;
2095  if (m_pFlist)
2096  delete [] m_pFlist;
2097 
2098  }
2099  void Init(int * flist);
2100  void MakeChildFaces(int & addpoint, HPoint * points, bool AddExtraPoints, int * newpoints, int * newpointslen);
2101  void Divide(int pnum, HPoint * points);
2102 
2103  bool CheckHit(HPoint & p, HPoint & normal, HPoint * plist, HPoint & pres);
2104  HMergeShellFace * FindHitFaceRecursive(HPoint & p, HPoint & normal, HPoint * plist, HPoint & respoint);
2105  HMergeShellFace * FindHitFace(HPoint & p, HPoint & normal, HPoint * plist, HPoint & respoint)
2106  {
2107  return FindHitFaceRecursive(p, normal, plist,respoint);
2108  }
2109  bool CheckIfColinear(HPoint * point);
2110 
2111  int GetLengthRecursive(int l);
2112 
2113  int GetLength()
2114  {
2115  return GetLengthRecursive(0);
2116 
2117  }
2118 
2119  int AddToFacelistRecursive(int * start, int l);
2120 
2121  int AddToFacelist(int * start)
2122  {
2123  return AddToFacelistRecursive(start, 0);
2124 
2125  }
2126 
2127 protected:
2128  HMergeShellFace * m_pChildFaces;
2129  int m_flen;
2130  int * m_pFlist;
2131  int m_ChildFaceNum;
2132 };
2133 
2134 
2135 
2136 class MVO_API ColorPiece{
2137 
2138 public:
2139  ColorPiece(int index[], int len, int col)
2140  {
2141  m_uvindex = new int[len];
2142  m_fllen = new int[len];
2143  m_flindex = new int[len];
2144  for (int i=0;i<len;i++)
2145  m_uvindex[i] = index[i];
2146  m_len = len;
2147  m_col = col;
2148  m_done = false;
2149 
2150  }
2151  ~ColorPiece()
2152  {
2153  delete [] m_uvindex;
2154  delete [] m_fllen;
2155  delete [] m_flindex;
2156  }
2157  int *m_uvindex;
2158  int *m_fllen;
2159  int *m_flindex;
2160  int m_len;
2161  int m_col;
2162 
2163  bool m_done;
2164 
2165 };
2166 
2167 class MVO_API ColorPieceList
2168 {
2169 public:
2170  ColorPieceList();
2171  ~ColorPieceList();
2172  void AddColorPiece(int index[], int len, int col);
2173  ColorPiece * FindMatch(int col, int ii, int ii2, int &rpos, int &rlen, bool &reverse);
2174 
2175  struct vlist_s* m_ColorPieceList;
2176 
2177 
2178 };
2179 
2180 class MVO_API HVerticalUtility :
2181  public HUtility
2182 {
2183 public:
2184 
2185  static void ColorizePointCloud(HC_KEY const segment);
2186 };
2187 
2188 
2189 
2190 class MVO_API HAbsoluteWindow
2191 {
2192 public:
2193  HAbsoluteWindow(HBaseView *view, HC_KEY key,float xpos, float ypos, float width, float height, AbsoluteWindowType xpos_type = RelativeLeft,
2194  AbsoluteWindowType ypos_type = RelativeTop, AbsoluteWindowType width_type = RelativeLeft,
2195  AbsoluteWindowType height_type = RelativeTop, bool sb = false);
2196  HAbsoluteWindow(HBaseView *view, HC_KEY key);
2197  void DecipherOptions();
2198  void AdjustX(float invalue, AbsoluteWindowType wt, float &outvalue);
2199  void AdjustY(float invalue, AbsoluteWindowType wt, float &outvalue);
2200  bool Adjust();
2201  static void AdjustAll(HBaseView *view);
2202  static bool SetWindow(HBaseView *view,float xpos, float ypos, float width, float height, AbsoluteWindowType xpos_type = RelativeLeft,
2203  AbsoluteWindowType ypos_type = RelativeTop, AbsoluteWindowType width_type = RelativeLeft,
2204  AbsoluteWindowType height_type = RelativeTop, bool sb = false);
2205  bool IsPositionInWindow(float x, float y);
2206  static bool IsPositionInWindow(HBaseView *view, float x, float y);
2207  static void CalculateLocalWindowPos(HBaseView *view, float x, float y, float &xout, float &yout);
2208  void CalculateLocalWindowPos(float x, float y, float &xout, float &yout);
2209  static void CalculateOuterWindowPos(HBaseView *view, float x, float y, float &xout, float &yout);
2210  void CalculateOuterWindowPos(float x, float y, float &xout, float &yout);
2211 
2212 
2213 
2214  HBaseView *m_pView;
2215  float m_width;
2216  float m_height;
2217  float m_xpos;
2218  float m_ypos;
2219  AbsoluteWindowType m_xpos_type;
2220  AbsoluteWindowType m_ypos_type;
2221  AbsoluteWindowType m_width_type;
2222  AbsoluteWindowType m_height_type;
2223 
2224  bool m_bShowBackground;
2225 
2226  HC_KEY m_key;
2227 
2228 };
2229 
2230 
2231 
2233 
2248 class MVO_API HUnicodeOptions
2249 {
2250 public:
2251 
2252  wchar_t* m_data;
2253  int m_length;
2254  bool m_valid;
2255 
2257  HUnicodeOptions();
2258 
2260  HUnicodeOptions(const HUnicodeOptions& in_data);
2261 
2262 
2264  ~HUnicodeOptions();
2265 
2266 
2270  bool IsValid();
2271 
2276  const __wchar_t * Show_Unicode_Options();
2277 
2282  const wchar_t* Show_One_Net_Unicode_Option(const __wchar_t* which);
2283 #ifdef _MSC_VER
2284  const unsigned short * Show_One_Net_Unicode_Option(const unsigned short * which);
2285 #endif
2286 
2291  const wchar_t * Show_One_Unicode_Option(const __wchar_t * which);
2292 #ifdef _MSC_VER
2293  const unsigned short * Show_One_Unicode_Option(const unsigned short * which);
2294 #endif
2295 
2299  const __wchar_t* Show_Net_Unicode_Options();
2300 
2301 private:
2302 
2303  void clear() {
2304  delete [] m_data;
2305  m_data = 0;
2306  m_length = 0;
2307  m_valid = false;
2308  }
2309 
2310 };
2311 
2312 
2313 
2314 class BREP_Topology;
2315 
2317 {
2318 public:
2319  BREP_Edge(HC_KEY edgekey)
2320  {
2321  m_edgekey = edgekey;
2322  m_vertex1 = INVALID_KEY;
2323  m_vertex2 = INVALID_KEY;
2324  }
2325 
2326  HC_KEY m_edgekey;
2327  HC_KEY m_vertex1;
2328  HC_KEY m_vertex2;
2329 
2330 };
2331 
2333 {
2334 public:
2335  BREP_CoEdge(BREP_Edge *edge)
2336  {
2337  m_edge = edge;
2338  }
2339 
2340  BREP_Edge * m_edge;
2341 };
2342 
2343 
2344 class MVO_API BREP_Face
2345 {
2346 public:
2347  BREP_Face(HC_KEY facekey);
2348  ~BREP_Face();
2349 
2350  BREP_Edge * AddCoEdge(BREP_Topology *topol, void *edgeid, HC_KEY edgekey);
2351 
2352 
2353  struct vlist_s * m_CoEdgeList;
2354  HC_KEY m_facekey;
2355 };
2356 
2357 class MVO_API BREP_Topology
2358 {
2359 public:
2360 
2361  struct vhash_s * m_FaceHash;
2362 
2363  struct vhash_s * m_EdgeHash;
2364  struct vhash_s * m_VertexHash;
2365 
2366  BREP_Face *m_CurrentFace;
2367  BREP_Topology();
2368  ~BREP_Topology();
2369  BREP_Face *AddFace(HC_KEY facekey);
2370  BREP_Face *GetFace(HC_KEY facekey);
2371  BREP_Edge *FindEdge(void *edgeid);
2372  BREP_Edge *AddEdge(void *edgeid, HC_KEY edgekey);
2373  HC_KEY AddVertex(void *vertexid, HPoint vpos);
2374  HC_KEY FindVertex(void *vertexid);
2375 
2376 
2377 
2378  BREP_Face *GetCurrentFace() { return m_CurrentFace; }
2379 
2380 };
2381 
2382 class H_FORMAT_TEXT;
2383 
2384 class MVO_API HBestImageDriver
2385 {
2386 private:
2387  H_FORMAT_TEXT * m_dvr;
2388 public:
2389  HBestImageDriver(char const * prefer_type = 0);
2390  ~HBestImageDriver();
2391 
2392  HC_KEY GetKey() const;
2393 
2394  operator char const* () const;
2395 };
2396 
2397 
2398 class MVO_API HPVOOptions
2399 {
2400  private:
2401  void * impl;
2402 
2403  public:
2404  HPVOOptions(char const * filename);
2405  ~HPVOOptions();
2406  char const * getOption(char const * option) const;
2407 };
2408 
2409 
2410 #ifdef H_PACK_8
2411 #pragma pack(pop)
2412 #endif
2413 
2414 #endif
The HPixelRGB class is the data type of a rgb pixel.
Definition: HGlobals.h:473
HShellWrapper()
Definition: HUtility.h:310
The HShellObject class is a simple wrapper for a shell.
Definition: HUtility.h:201
int point_list_len
The length of the point list,.
Definition: HUtility.h:270
int GetSecond() const
Definition: HUtility.h:99
int m_facepointer
Definition: HUtility.h:522
void Show_One_User_Option(const char *type, char *value)
double w
The knot value of a B-Surface vertex.
Definition: HUtility.h:591
int region_count
The number of regions in the shell.
Definition: HUtility.h:278
HShellWrapper(HC_KEY key)
Definition: HUtility.h:294
The HUtility class contains a set of utility functions and data structures used widely in MVO classes...
Definition: HUtility.h:786
Definition: HUtility.h:2136
static const float PI
default=3.1415926f
Definition: HUtility.h:790
Definition: HUtility.h:2332
Definition: HUtility.h:2357
char * m_data
actual char* to the user options
Definition: HUtility.h:721
Definition: HUtility.h:2190
Definition: HUtility.h:2180
wchar_t * m_data
actual char* to the user options
Definition: HUtility.h:2252
The HCamera class is the data type of a HOOPS Camera Attribute.
Definition: HUtility.h:540
HPoint * point_list
The list of vertices that define the shell.
Definition: HUtility.h:271
int GetFirst() const
Definition: HUtility.h:97
HPoint up_vector
The direction of up.
Definition: HUtility.h:545
bool valid
True if the object has been initialized.
Definition: HUtility.h:542
void Show_User_Options(char *list)
double y
The y-coordinate of a B-Surface vertex.
Definition: HUtility.h:589
The HShellRegion class is a simple wrapper for a shell&#39;s region.
Definition: HUtility.h:167
static bool IsSafeForSinglePrecision(int element_count, double const *elements, bool check_roundoff=false)
Definition: HUtility.h:2018
HVector * normal_list
The list of normal vectors associated with the shell.
Definition: HUtility.h:272
HC_KEY * patharray
Array of Keys.
Definition: HUtility.h:679
The HSmartSelItem - selection item which can handle instancing.
Definition: HSelectionItem.h:187
Definition: HUtility.h:2167
void Set(int first, int second)
Definition: HUtility.h:104
class HPoint HVector
The HVector class is the data type of a three-dimensional vector.
Definition: HGlobals.h:328
void EndFaceIteration()
Definition: HUtility.h:382
float field_height
The height of the field of view.
Definition: HUtility.h:547
int len
length of key array
Definition: HUtility.h:680
int face_count
The number of faces in the shell.
Definition: HUtility.h:276
int * m_Flist
The list that defines the configuration of the faces in the shell in relation to the points as descri...
Definition: HUtility.h:518
HC_KEY m_Key
The key of the shell.
Definition: HUtility.h:519
int m_plen
The number of points in the points list.
Definition: HUtility.h:512
Definition: HUtility.h:2082
The HUnicodeOptions class is a helper class which wraps up memory management for variable size Unicod...
Definition: HUtility.h:2248
double z
The z-coordinate of a B-Surface vertex.
Definition: HUtility.h:590
Definition: HUtility.h:62
The HUserOptions class is a helper class which wraps up memory management for variable size user opti...
Definition: HUtility.h:717
HPoint target
The area that the camera is directed at.
Definition: HUtility.h:544
void InvalidateCamera()
Definition: HUtility.h:556
HPolyline * m_pNextPolyline
A pointer to a single HPolyline object.
Definition: HUtility.h:608
int face_list_len
The length of the face list.
Definition: HUtility.h:274
int m_flen
The length of the face list.
Definition: HUtility.h:513
The HShellVertexData class encapsulates colormap index information associated with the vertices of a ...
Definition: HUtility.h:616
static bool IsSafeForSinglePrecision(double element, bool check_roundoff=false)
Definition: HUtility.h:2003
HPoint * m_pHPointArray
A pointer to an array of HPoint objects.
Definition: HUtility.h:607
void Show_Unicode_Options(unsigned short *options)
int m_totalplen
Definition: HUtility.h:526
The HBaseModel class is used to store and manage model information.
Definition: HBaseModel.h:47
The HPoint class is the data type of a three-dimensional point.
Definition: HGlobals.h:121
Definition: HIOManager.h:892
The HBaseView class defines and manages a view of model information.
Definition: HBaseView.h:332
Definition: HUtility.h:2384
The HShell class is the data type of a HOOPS Shell.
Definition: HUtility.h:250
int m_length
length of current user option
Definition: HUtility.h:722
int * region_list
The list that defines the set of regions in the shell.
Definition: HUtility.h:279
Definition: HUtility.h:2042
void Show_One_Unicode_Option(const unsigned short *requestedOption, unsigned short *options)
The HShellFace class is a simple wrapper for a shell&#39;s face.
Definition: HUtility.h:130
static const float EH_Epsilon
default=0.01
Definition: HUtility.h:795
The HShellWrapper class is wraps shell information and provides methods to manipulate this informatio...
Definition: HUtility.h:287
The HShellEdge class is a simple wrapper for a shell&#39;s edge.
Definition: HUtility.h:87
HPoint position
The location of the camera.
Definition: HUtility.h:543
double x
The x-coordinate of a B-Surface vertex.
Definition: HUtility.h:588
void Set(double X, double Y, double Z, double W)
Definition: HUtility.h:595
Definition: HUtility.h:2316
The HPlane class is the data type of a plane.
Definition: HGlobals.h:335
int m_PointCount
Number of points in the polyline.
Definition: HUtility.h:606
Definition: HUtility.h:2398
The HShowContentsWithPathType struct is used by HUtility to store a keypath.
Definition: HUtility.h:677
The HBSurfVertex class is the data type of a B-Surface vertex.
Definition: HUtility.h:585
int * face_list
The face list that defines how faces are formed in the shell.
Definition: HUtility.h:275
HC_KEY GetKey()
Definition: HUtility.h:351
HShellEdge(int iFirst=0, int iSecond=0)
Definition: HUtility.h:93
The HPolyline class is the data type for a three-dimensional polyline.
Definition: HUtility.h:603
Definition: HUtility.h:47
Definition: HUtility.h:2344
int m_length
length of current user option
Definition: HUtility.h:2253
float field_width
The width of the field of view.
Definition: HUtility.h:546
int m_totalflen
Definition: HUtility.h:524