########
HUtility
########

.. cpp:namespace:: HUtility

.. default-domain:: cpp

Types
=====

=== ================================
..  :cpp:enumerator:`~HUtility::@3` 
..  :cpp:enumerator:`~HUtility::@4` 
=== ================================

Fields
======

============ =================================
..           :cpp:enum:`~HUtility::X`         
..           :cpp:enum:`~HUtility::Y`         
..           :cpp:enum:`~HUtility::Z`         
..           :cpp:enum:`~HUtility::W`         
..           :cpp:enum:`~HUtility::XY`        
..           :cpp:enum:`~HUtility::XZ`        
..           :cpp:enum:`~HUtility::YZ`        
float const  :cpp:var:`~HUtility::PI`         
float const  :cpp:var:`~HUtility::EH_Epsilon` 
============ =================================

Functions
=========

================================= ===================================================================================================================================================================================================================================================================================================================================================================================================
void                              :cpp:func:`Order <static void HUtility::Order(HPoint *one, HPoint *two)>`                                                                                                                                                                                                                                                                                                                          
void                              :cpp:func:`Find_Relative_Path <static void HUtility::Find_Relative_Path(HC_KEY from_seg_key, HC_KEY to_seg_key, char *path)>`                                                                                                                                                                                                                                                                      
float                             :cpp:func:`GetTime <static float HUtility::GetTime()>`                                                                                                                                                                                                                                                                                                                                             
void                              :cpp:func:`ClampPointToWindow <static void HUtility::ClampPointToWindow(HPoint *point)>`                                                                                                                                                                                                                                                                                                           
HC_KEY                            :cpp:func:`InsertBox <static HC_KEY HUtility::InsertBox(HPoint const *max, HPoint const *min)>`                                                                                                                                                                                                                                                                                                    
HC_KEY                            :cpp:func:`InsertWireframeBox <static HC_KEY HUtility::InsertWireframeBox(HPoint *max, HPoint *min)>`                                                                                                                                                                                                                                                                                              
void                              :cpp:func:`GenerateCuboidPoints <static void HUtility::GenerateCuboidPoints(HPoint const *max, HPoint const *min, HPoint points[])>`                                                                                                                                                                                                                                                               
HC_KEY                            :cpp:func:`InsertRectangle <static HC_KEY HUtility::InsertRectangle(char const *seg, float x0, float y0, float x1, float y1, float z=0.0f, bool fill=false)>`                                                                                                                                                                                                                                      
void                              :cpp:func:`InsertArrow <static void HUtility::InsertArrow(float stick_length, float tip_length, float stick_radius, float arrow_radius, char const *text, char const *stick_color, char const *tip_color, int num_sides=6, float tip_falloff=0.05, bool reverse=true)>`                                                                                                                            
void                              :cpp:func:`ComputeDoublePrecisionCrossProduct <static void HUtility::ComputeDoublePrecisionCrossProduct(double const *vector1, double const *vector2, double up[])>`                                                                                                                                                                                                                               
double                            :cpp:func:`ComputeDoublePrecisionDotProduct <static double HUtility::ComputeDoublePrecisionDotProduct(double const *vector1, double const *vector2)>`                                                                                                                                                                                                                                              
double                            :cpp:func:`ComputeDoublePrecisionVectorLength <static double HUtility::ComputeDoublePrecisionVectorLength(double const *vector1)>`                                                                                                                                                                                                                                                                 
void                              :cpp:func:`GetViewplaneVectors <static void HUtility::GetViewplaneVectors(HC_KEY segment_key, double view[], double up[])>`                                                                                                                                                                                                                                                                        
void                              :cpp:func:`NormalizeDoublePrecisionVector <static void HUtility::NormalizeDoublePrecisionVector(double vector1[])>`                                                                                                                                                                                                                                                                                
bool                              :cpp:func:`PointsEqual <static bool HUtility::PointsEqual(HPoint const *point1, HPoint const *point2)>`                                                                                                                                                                                                                                                                                            
bool                              :cpp:func:`CreateAxisCircle <static bool HUtility::CreateAxisCircle(HPoint const &center, float radius, int axis, bool convert=true)>`                                                                                                                                                                                                                                                             
void                              :cpp:func:`RotateToVector <static void HUtility::RotateToVector(HPoint const &start, HPoint const &end, bool doTranslation=true)>`                                                                                                                                                                                                                                                                 
void                              :cpp:func:`SmoothTransition <static void HUtility::SmoothTransition(HPoint const &co, HPoint const &to, HPoint const &uo, float fieldwidtho, float fieldheighto, HPoint const &cn, HPoint const &tn, HPoint const &un, float fieldwidthn, float fieldheightn, HBaseView *view)>`                                                                                                                   
void                              :cpp:func:`SmoothTransition <static void HUtility::SmoothTransition(HCamera old_camera, HCamera const &new_camera, HBaseView *view)>`                                                                                                                                                                                                                                                              
bool                              :cpp:func:`CamerasEqual <static bool HUtility::CamerasEqual(HCamera const &camera1, HCamera const &camera2)>`                                                                                                                                                                                                                                                                                      
void                              :cpp:func:`ComputeVectorToVectorRotationMatrix <static void HUtility::ComputeVectorToVectorRotationMatrix(float matrix[], HPoint v1, HPoint v2)>`                                                                                                                                                                                                                                                  
bool                              :cpp:func:`ExtractRGB <static bool HUtility::ExtractRGB(char *text, float &r, float &g, float &b)>`                                                                                                                                                                                                                                                                                                
void                              :cpp:func:`TransitionQuaternion <static void HUtility::TransitionQuaternion(float quat_old[], float quat_new[], float t, float qt[])>`                                                                                                                                                                                                                                                             
void                              :cpp:func:`MatrixToQuaternion <static void HUtility::MatrixToQuaternion(float const matrix[], float quaternion[])>`                                                                                                                                                                                                                                                                                
void                              :cpp:func:`QuaternionToMatrix <static void HUtility::QuaternionToMatrix(float const quaternion[], float matrix[])>`                                                                                                                                                                                                                                                                                
void                              :cpp:func:`SmoothQuaternionTransition <static void HUtility::SmoothQuaternionTransition(HBaseView *m_pView, char const *old_seg, char const *new_seg, int num_of_transitions)>`                                                                                                                                                                                                                    
void                              :cpp:func:`SmoothMatrixTransition <static void HUtility::SmoothMatrixTransition(HBaseView *m_pView, HC_KEY seg_key, float new_matrix[])>`                                                                                                                                                                                                                                                          
void                              :cpp:func:`MultiSmoothTransitions <static void HUtility::MultiSmoothTransitions(HBaseView *m_pView, int num_keys, HC_KEY *seg_key, float const new_matrix[], HCamera *new_camera=0)>`                                                                                                                                                                                                              
:doc:`classHPoint`                :cpp:func:`GetCentroid <static HPoint HUtility::GetCentroid(HC_KEY seg_key)>`                                                                                                                                                                                                                                                                                                                      
:doc:`classHPoint`                :cpp:func:`GetTransformedCentroid <static HPoint HUtility::GetTransformedCentroid(HC_KEY seg_key, float const matrix[]=0)>`                                                                                                                                                                                                                                                                        
void                              :cpp:func:`URIencode <static void HUtility::URIencode(char const *in_string, unsigned long n, char *out_buffer)>`                                                                                                                                                                                                                                                                                  
void                              :cpp:func:`URIdecode <static void HUtility::URIdecode(char const *in_string, char *out_buffer, unsigned long *n)>`                                                                                                                                                                                                                                                                                 
void                              :cpp:func:`GetCameraFromMatrix <static void HUtility::GetCameraFromMatrix(float const *matrix, HPoint *position, HPoint *up_vector, HPoint *translation)>`                                                                                                                                                                                                                                         
void                              :cpp:func:`GetMatrixFromCamera <static void HUtility::GetMatrixFromCamera(HPoint const &target, HPoint const &position, HPoint up_vector, HPoint const &translation, float matrix[])>`                                                                                                                                                                                                             
void                              :cpp:func:`GetCameraFromGLFrustum <static void HUtility::GetCameraFromGLFrustum(double const left, double const right, double const bottom, double const top, double const near_z, double const far_z, bool const perspective, HPoint &pos, HPoint &target, HPoint &up, char *projection, double &width, double &height, double &near_limit)>`                                                     
bool                              :cpp:func:`PushAttribute <static bool HUtility::PushAttribute(char const *attName)>`                                                                                                                                                                                                                                                                                                               
void                              :cpp:func:`PushAttribute <static void HUtility::PushAttribute(char const *attName, char const *attText)>`                                                                                                                                                                                                                                                                                          
bool                              :cpp:func:`PopAttribute <static bool HUtility::PopAttribute(char const *attName)>`                                                                                                                                                                                                                                                                                                                 
bool                              :cpp:func:`ModifyPushedAttribute <static bool HUtility::ModifyPushedAttribute(char const *attName, char const *newStyle)>`                                                                                                                                                                                                                                                                         
bool                              :cpp:func:`ShowPushedAttribute <static bool HUtility::ShowPushedAttribute(char const *attName, HUserOptions &attText)>`                                                                                                                                                                                                                                                                            
void                              :cpp:func:`Recursive_Merge_Shells <static void HUtility::Recursive_Merge_Shells(HShell *total_info, HShell *max_info, bool do_recurse, bool delete_orig_shells=false, bool insert_null_lods=false)>`                                                                                                                                                                                               
HC_KEY                            :cpp:func:`Merge_Shells <static HC_KEY HUtility::Merge_Shells(bool do_recurse, bool delete_orig_shells=false, bool optimize_shell=true, bool generate_regions=false)>`                                                                                                                                                                                                                             
HC_KEY                            :cpp:func:`Merge_Shells_Generate_Regions <static HC_KEY HUtility::Merge_Shells_Generate_Regions(int num_shells, HC_KEY shell_keys[], bool delete_orig_shells=false)>`                                                                                                                                                                                                                              
void                              :cpp:func:`Generate_LODs <static void HUtility::Generate_LODs(bool do_recurse=true, bool delete_orig_shells=false, int n_lod_levels=2, float reduction_ratio=0.20)>`                                                                                                                                                                                                                               
bool                              :cpp:func:`Segment_Shell_Allocate <static bool HUtility::Segment_Shell_Allocate(HShell *total_info, HShell *max_info, bool do_recurse)>`                                                                                                                                                                                                                                                           
void                              :cpp:func:`Shell_Search <static void HUtility::Shell_Search(HShell *total_info, HShell *max_info, bool do_recurse)>`                                                                                                                                                                                                                                                                               
void                              :cpp:func:`OptimizeSegmentTree <static void HUtility::OptimizeSegmentTree(HC_KEY old_seg_key, HC_KEY *new_seg_key, bool merge_shells=true)>`                                                                                                                                                                                                                                                       
void                              :cpp:func:`CountShellData <static void HUtility::CountShellData(HC_KEY shell_key, int *face_count, int *vertice_count, int *triangle_count, int *tristrips_count=0)>`                                                                                                                                                                                                                              
void                              :cpp:func:`FindFileNameExtension <static void HUtility::FindFileNameExtension(char const *filename_in, char *ext_out)>`                                                                                                                                                                                                                                                                            
void                              :cpp:func:`FindFileNameExtension <static void HUtility::FindFileNameExtension(__wchar_t const *filename_in, __wchar_t *ext_out, int size=-1)>`                                                                                                                                                                                                                                                     
void                              :cpp:func:`FindUnicodeFileNameExtension <static void HUtility::FindUnicodeFileNameExtension(unsigned short const *filename_in, char *ext_out)>`                                                                                                                                                                                                                                                    
void                              :cpp:func:`FindFileNameAndDirectory <static void HUtility::FindFileNameAndDirectory(char const *filename_in, char *dir_out, char *filename_out)>`                                                                                                                                                                                                                                                  
void                              :cpp:func:`FindFileNameAndDirectory <static void HUtility::FindFileNameAndDirectory(__wchar_t const *filename_in, __wchar_t *dir_out, __wchar_t *filename_out)>`                                                                                                                                                                                                                                   
char const *                      :cpp:func:`extra_pointer_format <static char const  * HUtility::extra_pointer_format()>`                                                                                                                                                                                                                                                                                                           
HC_KEY                            :cpp:func:`CreateScaleIndependentSegment <static HC_KEY HUtility::CreateScaleIndependentSegment(char const *segname, bool SetCallback=true)>`                                                                                                                                                                                                                                                      
HC_KEY                            :cpp:func:`GetScaleIndependentGeomSegmentKey <static HC_KEY HUtility::GetScaleIndependentGeomSegmentKey(HC_KEY segkey)>`                                                                                                                                                                                                                                                                           
void                              :cpp:func:`SetScaleIndependentGeomPosition <static void HUtility::SetScaleIndependentGeomPosition(HC_KEY segkey, float x, float y, float z)>`                                                                                                                                                                                                                                                      
void                              :cpp:func:`GetScaleIndependentGeomPosition <static void HUtility::GetScaleIndependentGeomPosition(HC_KEY segkey, float &x, float &y, float &z)>`                                                                                                                                                                                                                                                   
void                              :cpp:func:`RegisterCallbacks <static void HUtility::RegisterCallbacks()>`                                                                                                                                                                                                                                                                                                                          
bool                              :cpp:func:`IsModelKey <static bool HUtility::IsModelKey(HC_KEY modelkey, HC_KEY objectkey)>`                                                                                                                                                                                                                                                                                                       
HC_KEY                            :cpp:func:`UserOptionExists <static HC_KEY HUtility::UserOptionExists(HC_KEY key, char const *attrib, char *result)>`                                                                                                                                                                                                                                                                              
void                              :cpp:func:`InsertRotatedArrow <static void HUtility::InsertRotatedArrow(float tip_length, float stick_radius, float tip_radius, float distance, int adelta, float rotang, char const *stick_color, char const *tip_color, int num_sides)>`                                                                                                                                                         
int                               :cpp:func:`CalculateKeyPath <static int HUtility::CalculateKeyPath(HC_KEY startkey, HBaseView const *view, HC_KEY keyarray[], int maxarray)>`                                                                                                                                                                                                                                                      
bool                              :cpp:func:`SegmentExists <static bool HUtility::SegmentExists(char const *segment)>`                                                                                                                                                                                                                                                                                                               
void                              :cpp:func:`UnsetAttributes <static void HUtility::UnsetAttributes()>`                                                                                                                                                                                                                                                                                                                              
int                               :cpp:func:`IsChildOf <static int HUtility::IsChildOf(HC_KEY owner, HC_KEY child, HC_KEY klist[]=0)>`                                                                                                                                                                                                                                                                                               
bool                              :cpp:func:`IsIdentityMatrix <static bool HUtility::IsIdentityMatrix(float const matrix[])>`                                                                                                                                                                                                                                                                                                        
void                              :cpp:func:`ComputeShellNormal <static void HUtility::ComputeShellNormal(HC_KEY skey, HPoint &tnormal)>`                                                                                                                                                                                                                                                                                            
HC_KEY                            :cpp:func:`SelectUnderCursor <static HC_KEY HUtility::SelectUnderCursor(HBaseView *view, float x, float y, bool doSelection=true, bool DeSelect=false)>`                                                                                                                                                                                                                                           
HC_KEY                            :cpp:func:`SmartSelectUnderCursor <static HC_KEY HUtility::SmartSelectUnderCursor(HBaseView *view, float x, float y, bool doSelection=true, bool DeSelect=false)>`                                                                                                                                                                                                                                 
bool                              :cpp:func:`ShowOneHeuristic <static bool HUtility::ShowOneHeuristic(char const *type, char *res=0)>`                                                                                                                                                                                                                                                                                               
bool                              :cpp:func:`ShowOneRenderingOption <static bool HUtility::ShowOneRenderingOption(char const *type, char *res=0)>`                                                                                                                                                                                                                                                                                   
float                             :cpp:func:`EaseInEaseOut <static float HUtility::EaseInEaseOut(float t, float a, float b, float c)>`                                                                                                                                                                                                                                                                                               
void                              :cpp:func:`UnwindIncludes <static void HUtility::UnwindIncludes(HC_KEY &key)>`                                                                                                                                                                                                                                                                                                                     
void                              :cpp:func:`UnwindIncludes <static void HUtility::UnwindIncludes(HC_KEY &newkey, HC_KEY const keys[], int count)>`                                                                                                                                                                                                                                                                                  
bool                              :cpp:func:`SafeSetUserOption <static bool HUtility::SafeSetUserOption(char const *opt)>`                                                                                                                                                                                                                                                                                                           
bool                              :cpp:func:`SafeShowUserOption <static bool HUtility::SafeShowUserOption(char *opt)>`                                                                                                                                                                                                                                                                                                               
void                              :cpp:func:`ProjectShell <static void HUtility::ProjectShell(HC_KEY shellkey)>`                                                                                                                                                                                                                                                                                                                     
HC_KEY                            :cpp:func:`MergeShells <static HC_KEY HUtility::MergeShells(HC_KEY shell1, HC_KEY shell2)>`                                                                                                                                                                                                                                                                                                        
void                              :cpp:func:`ShowModellingMatrix <static void HUtility::ShowModellingMatrix(float segment_modelling_matrix[])>`                                                                                                                                                                                                                                                                                      
void                              :cpp:func:`ConvertLocalPixelsToLocalWindow <static void HUtility::ConvertLocalPixelsToLocalWindow(HBaseView const *view, HPoint *in_system, HPoint *out_system=0)>`                                                                                                                                                                                                                                
HC_KEY                            :cpp:func:`GrabSegment <static HC_KEY HUtility::GrabSegment(HC_KEY key)>`                                                                                                                                                                                                                                                                                                                          
void                              :cpp:func:`RenameSegment <static void HUtility::RenameSegment(HC_KEY segkey, char const *newname)>`                                                                                                                                                                                                                                                                                                
void                              :cpp:func:`InterpolateNormalAlongEdge <static void HUtility::InterpolateNormalAlongEdge(HPoint &p1, HPoint &n1, HPoint &p2, HPoint &n2, HPoint &p3, HPoint &n3)>`                                                                                                                                                                                                                                  
void                              :cpp:func:`ShowNormals <static void HUtility::ShowNormals(HC_KEY shellkey, float normallength)>`                                                                                                                                                                                                                                                                                                   
bool                              :cpp:func:`IsSegmentKey <static bool HUtility::IsSegmentKey(HC_KEY key)>`                                                                                                                                                                                                                                                                                                                          
int                               :cpp:func:`FindContents <static int HUtility::FindContents(HC_KEY &key, bool original=false)>`                                                                                                                                                                                                                                                                                                     
int                               :cpp:func:`CalculateMajorAxis <static int HUtility::CalculateMajorAxis(HBaseView const *view)>`                                                                                                                                                                                                                                                                                                    
HC_KEY                            :cpp:func:`FindOneObject <static HC_KEY HUtility::FindOneObject(char const *type, bool local_search=false)>`                                                                                                                                                                                                                                                                                       
void                              :cpp:func:`CloseAllSegments <static void HUtility::CloseAllSegments(HC_KEY endkey=(-1L))>`                                                                                                                                                                                                                                                                                                         
void                              :cpp:func:`ReadjustTarget <static void HUtility::ReadjustTarget(HBaseView const *view)>`                                                                                                                                                                                                                                                                                                           
bool                              :cpp:func:`GetAllowAnimation <static bool HUtility::GetAllowAnimation(HC_KEY key)>`                                                                                                                                                                                                                                                                                                                
void                              :cpp:func:`SuppressAnimation <static void HUtility::SuppressAnimation()>`                                                                                                                                                                                                                                                                                                                          
int                               :cpp:func:`FindFaceByIndex <static int HUtility::FindFaceByIndex(int findex, int const flist[], int flen)>`                                                                                                                                                                                                                                                                                        
bool                              :cpp:func:`ShowOneUserOption <static bool HUtility::ShowOneUserOption(char const *option, char *res)>`                                                                                                                                                                                                                                                                                             
HC_KEY                            :cpp:func:`GetNextRenumberedKey <static HC_KEY HUtility::GetNextRenumberedKey(HBaseView const *view)>`                                                                                                                                                                                                                                                                                             
void                              :cpp:func:`NameSegments <static void HUtility::NameSegments(HC_KEY &key, HBaseView const *view)>`                                                                                                                                                                                                                                                                                                  
void                              :cpp:func:`MoveToTemp <static void HUtility::MoveToTemp(HC_KEY movekey, HC_KEY tempkey)>`                                                                                                                                                                                                                                                                                                          
void                              :cpp:func:`ShowContentsWithPath <static void HUtility::ShowContentsWithPath(char const *entitytypes, struct vlist_s **ret_pathlist, bool storePath=false, bool includeIncludes=true, bool filterIncludes=true)>`                                                                                                                                                                                   
int                               :cpp:func:`ustrlen <static int HUtility::ustrlen(unsigned short *text)>`                                                                                                                                                                                                                                                                                                                           
bool                              :cpp:func:`RLECompress <static bool HUtility::RLECompress(int in_len, unsigned char const *in_buf, int *out_len, unsigned char *out_buf)>`                                                                                                                                                                                                                                                         
bool                              :cpp:func:`ZlibCompress <static bool HUtility::ZlibCompress(int in_len, unsigned char const *in_buf, int &out_len, unsigned char *out_buf)>`                                                                                                                                                                                                                                                       
bool                              :cpp:func:`ZlibDecompress <static bool HUtility::ZlibDecompress(int const in_len, unsigned char const *const in_buf, int &out_len, unsigned char *const out_buf)>`                                                                                                                                                                                                                                 
unsigned short *                  :cpp:func:`uconvert <static unsigned short * HUtility::uconvert(char const *text)>`                                                                                                                                                                                                                                                                                                                
bool                              :cpp:func:`BuildIncludePath <static bool HUtility::BuildIncludePath(HC_KEY objectkey, HC_KEY const includelist[], int ilength, HC_KEY fullpath[], int *fplength, HC_KEY matchkey=(-1L))>`                                                                                                                                                                                                          
void                              :cpp:func:`BuildIncludePathFromSelection <static void HUtility::BuildIncludePathFromSelection(HSmartSelItem *sitem, int &plen, HC_KEY fullpath[])>`                                                                                                                                                                                                                                                
void                              :cpp:func:`MakeViewSnapshot <static void HUtility::MakeViewSnapshot(HBaseView *view, int width, int height, char **data)>`                                                                                                                                                                                                                                                                         
void                              :cpp:func:`MakeViewSnapshot <static void HUtility::MakeViewSnapshot(HBaseView *view, HC_KEY image_key)>`                                                                                                                                                                                                                                                                                           
int                               :cpp:func:`ConstrainToVector <static int HUtility::ConstrainToVector(float const matrix_in[], HVector const &vector, float matrix_out[])>`                                                                                                                                                                                                                                                         
void                              :cpp:func:`Camera_To_Transform <static void HUtility::Camera_To_Transform(HCamera const *camera, float pos[], float projection_matrix[], float complete_matrix[])>`                                                                                                                                                                                                                                
void                              :cpp:func:`LocalPixelsToWorld <static void HUtility::LocalPixelsToWorld(HCamera const *camera, bool righthanded, float xres, float yres, int xwpix, int ywpix, float result[])>`                                                                                                                                                                                                                   
float                             :cpp:func:`ComputeAngleBetweenVector <static float HUtility::ComputeAngleBetweenVector(HPoint p1, HPoint p2)>`                                                                                                                                                                                                                                                                                     
int                               :cpp:func:`strlen16 <static int HUtility::strlen16(unsigned short const *p16)>`                                                                                                                                                                                                                                                                                                                    
void                              :cpp:func:`CalculateBoundingInfo <static void HUtility::CalculateBoundingInfo(HC_KEY startkey, HPoint &min, HPoint &max, HPoint &delta, HPoint &mid)>`                                                                                                                                                                                                                                             
long                              :cpp:func:`ClipPolygonAgainstPlane <static long HUtility::ClipPolygonAgainstPlane(long vertexCount, HPoint const vertex[], float const plane[], HPoint result[], bool *noCut=0)>`                                                                                                                                                                                                                  
:cpp:enumerator:`~HFileIOResult`  :cpp:func:`TwoPassPrint <static HFileIOResult HUtility::TwoPassPrint(char const *driver, HOutputHandlerOptions *options)>`                                                                                                                                                                                                                                                                         
HC_KEY                            :cpp:func:`OpenSegmentFromKey <static HC_KEY HUtility::OpenSegmentFromKey(HC_KEY key, char const *segment)>`                                                                                                                                                                                                                                                                                       
bool                              :cpp:func:`IsPointInsideAllEdges <static bool HUtility::IsPointInsideAllEdges(float const *pt, float const points1[], int len, int const face1[], float const plane1[], float fudge)>`                                                                                                                                                                                                             
void                              :cpp:func:`IntersectionLinePlane <static void HUtility::IntersectionLinePlane(HPoint const *p1, HPoint const *p2, HPlane const *p, HPoint *res)>`                                                                                                                                                                                                                                                  
void                              :cpp:func:`DeleteManipulators <static void HUtility::DeleteManipulators(HC_KEY key)>`                                                                                                                                                                                                                                                                                                              
void                              :cpp:func:`MergePointsIntoShell <static void HUtility::MergePointsIntoShell(int num_shell_points, HPoint plist1[], int num_shell_facelist, int flist1[], int num_merge_points, HPoint merge_points[], HPoint merge_vectors[], float tolerance, bool AddExtraPoints, int newpoints[], int *newpointslen)>`                                                                                          
void                              :cpp:func:`SubdivideShells <static void HUtility::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)>`                                                                                                                                           
void                              :cpp:func:`MergePolylines <static void HUtility::MergePolylines()>`                                                                                                                                                                                                                                                                                                                                
void                              :cpp:func:`CreateZebraStripeTexture <static void HUtility::CreateZebraStripeTexture(int width, int height, int stripwidth, bool horizontal, HPixelRGB const &colorstripes, HPixelRGB const &colorbackground)>`                                                                                                                                                                                     
void                              :cpp:func:`ascii_to_unicode <static void HUtility::ascii_to_unicode(char const *ascii, unsigned short *unicode)>`                                                                                                                                                                                                                                                                                  
void                              :cpp:func:`unicode_to_ascii <static void HUtility::unicode_to_ascii(unsigned short const *unicode, char *ascii)>`                                                                                                                                                                                                                                                                                  
void                              :cpp:func:`BatchRead <static void HUtility::BatchRead(HBaseModel *model, char const *directory, char const *extension)>`                                                                                                                                                                                                                                                                           
void                              :cpp:func:`AdjustPositionToPlane <static void HUtility::AdjustPositionToPlane(HBaseView const *view, HPoint &position, HPoint point_in_plane)>`                                                                                                                                                                                                                                                    
void                              :cpp:func:`CalculateCornerImagePosition <static void HUtility::CalculateCornerImagePosition(HBaseView const *view, int iwidth, int iheight, HWindowCorner corner, float &posx, float &posy)>`                                                                                                                                                                                                      
void                              :cpp:func:`OptimizeModelByGrid <static void HUtility::OptimizeModelByGrid(HBaseView const *view, ShellToRegionMapper *mapper)>`                                                                                                                                                                                                                                                                    
void                              :cpp:func:`DecipherTextureString <static void HUtility::DecipherTextureString(char *texdef, char *Source, bool *DownSampling=0, bool *DownSamplingSet=0, char *ParameterizationSource=0, char *InterpolationFilter=0, char *DecimationFilter=0, char *Layout=0, char *Tiling=0, bool *ValueScaleSet=0, bool *ValueScale=0, float *ValueScaleMin=0, float *ValueScaleMax=0, char *BlendingMode=0)>` 
bool                              :cpp:func:`IsSafeForSinglePrecision <static bool HUtility::IsSafeForSinglePrecision(double element, bool check_roundoff=false)>`                                                                                                                                                                                                                                                                   
bool                              :cpp:func:`IsSafeForSinglePrecision <static bool HUtility::IsSafeForSinglePrecision(int element_count, double const *elements, bool check_roundoff=false)>`                                                                                                                                                                                                                                        
================================= ===================================================================================================================================================================================================================================================================================================================================================================================================

.. cpp:namespace:: nullptr

Detailed Description
====================

.. doxygenclass:: HUtility
   :project: mvo
   :members:
   :undoc-members:



