tesseract
3.03
|
00001 /* -*-C-*- 00002 ******************************************************************************** 00003 * 00004 * File: helpers.h 00005 * Description: General utility functions 00006 * Author: Daria Antonova 00007 * Created: Wed Apr 8 14:37:00 2009 00008 * Language: C++ 00009 * Package: N/A 00010 * Status: Reusable Software Component 00011 * 00012 * (c) Copyright 2009, Google Inc. 00013 ** Licensed under the Apache License, Version 2.0 (the "License"); 00014 ** you may not use this file except in compliance with the License. 00015 ** You may obtain a copy of the License at 00016 ** http://www.apache.org/licenses/LICENSE-2.0 00017 ** Unless required by applicable law or agreed to in writing, software 00018 ** distributed under the License is distributed on an "AS IS" BASIS, 00019 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 00020 ** See the License for the specific language governing permissions and 00021 ** limitations under the License. 00022 * 00023 ********************************************************************************/ 00024 00025 #ifndef TESSERACT_CCUTIL_HELPERS_H_ 00026 #define TESSERACT_CCUTIL_HELPERS_H_ 00027 00028 #include <stdio.h> 00029 #include <string.h> 00030 00031 // Remove newline (if any) at the end of the string. 00032 inline void chomp_string(char *str) { 00033 int last_index = strlen(str) - 1; 00034 while (last_index >= 0 && 00035 (str[last_index] == '\n' || str[last_index] == '\r')) { 00036 str[last_index--] = '\0'; 00037 } 00038 } 00039 00040 // Advance the current pointer of the file if it points to a newline character. 00041 inline void SkipNewline(FILE *file) { 00042 if (fgetc(file) != '\n') fseek(file, -1, SEEK_CUR); 00043 } 00044 00045 // Swaps the two args pointed to by the pointers. 00046 // Operator= and copy constructor must work on T. 00047 template<typename T> inline void Swap(T* p1, T* p2) { 00048 T tmp(*p2); 00049 *p2 = *p1; 00050 *p1 = tmp; 00051 } 00052 00053 // qsort function to sort 2 floats. 00054 inline int sort_floats(const void *arg1, const void *arg2) { 00055 float diff = *((float *) arg1) - *((float *) arg2); 00056 if (diff > 0) { 00057 return 1; 00058 } else if (diff < 0) { 00059 return -1; 00060 } else { 00061 return 0; 00062 } 00063 } 00064 00065 // return the smallest multiple of block_size greater than or equal to n. 00066 inline int RoundUp(int n, int block_size) { 00067 return block_size * ((n + block_size - 1) / block_size); 00068 } 00069 00070 // Clip a numeric value to the interval [lower_bound, upper_bound]. 00071 template<typename T> 00072 inline T ClipToRange(const T& x, const T& lower_bound, const T& upper_bound) { 00073 if (x < lower_bound) 00074 return lower_bound; 00075 if (x > upper_bound) 00076 return upper_bound; 00077 return x; 00078 } 00079 00080 // Extend the range [lower_bound, upper_bound] to include x. 00081 template<typename T1, typename T2> 00082 inline void UpdateRange(const T1& x, T2* lower_bound, T2* upper_bound) { 00083 if (x < *lower_bound) 00084 *lower_bound = x; 00085 if (x > *upper_bound) 00086 *upper_bound = x; 00087 } 00088 00089 // Decrease lower_bound to be <= x_lo AND increase upper_bound to be >= x_hi. 00090 template<typename T1, typename T2> 00091 inline void UpdateRange(const T1& x_lo, const T1& x_hi, 00092 T2* lower_bound, T2* upper_bound) { 00093 if (x_lo < *lower_bound) 00094 *lower_bound = x_lo; 00095 if (x_hi > *upper_bound) 00096 *upper_bound = x_hi; 00097 } 00098 00099 // Intersect the range [*lower2, *upper2] with the range [lower1, upper1], 00100 // putting the result back in [*lower2, *upper2]. 00101 // If non-intersecting ranges are given, we end up with *lower2 > *upper2. 00102 template<typename T> 00103 inline void IntersectRange(const T& lower1, const T& upper1, 00104 T* lower2, T* upper2) { 00105 if (lower1 > *lower2) 00106 *lower2 = lower1; 00107 if (upper1 < *upper2) 00108 *upper2 = upper1; 00109 } 00110 00111 // Proper modulo arithmetic operator. Returns a mod b that works for -ve a. 00112 // For any integer a and positive b, returns r : 0<=r<b and a=n*b + r for 00113 // some integer n. 00114 inline int Modulo(int a, int b) { 00115 return (a % b + b) % b; 00116 } 00117 00118 // Integer division operator with rounding that works for negative input. 00119 // Returns a divided by b, rounded to the nearest integer, without double 00120 // counting at 0. With simple rounding 1/3 = 0, 0/3 = 0 -1/3 = 0, -2/3 = 0, 00121 // -3/3 = 0 and -4/3 = -1. 00122 // I want 1/3 = 0, 0/3 = 0, -1/3 = 0, -2/3 = -1, -3/3 = -1 and -4/3 = -1. 00123 inline int DivRounded(int a, int b) { 00124 if (b < 0) return -DivRounded(a, -b); 00125 return a >= 0 ? (a + b / 2) / b : (a - b / 2) / b; 00126 } 00127 00128 // Return a double cast to int with rounding. 00129 inline int IntCastRounded(double x) { 00130 return x >= 0.0 ? static_cast<int>(x + 0.5) : -static_cast<int>(-x + 0.5); 00131 } 00132 00133 // Reverse the order of bytes in a n byte quantity for big/little-endian switch. 00134 inline void ReverseN(void* ptr, int num_bytes) { 00135 char *cptr = reinterpret_cast<char *>(ptr); 00136 int halfsize = num_bytes / 2; 00137 for (int i = 0; i < halfsize; ++i) { 00138 char tmp = cptr[i]; 00139 cptr[i] = cptr[num_bytes - 1 - i]; 00140 cptr[num_bytes - 1 - i] = tmp; 00141 } 00142 } 00143 00144 // Reverse the order of bytes in a 16 bit quantity for big/little-endian switch. 00145 inline void Reverse16(void *ptr) { 00146 ReverseN(ptr, 2); 00147 } 00148 00149 // Reverse the order of bytes in a 32 bit quantity for big/little-endian switch. 00150 inline void Reverse32(void *ptr) { 00151 ReverseN(ptr, 4); 00152 } 00153 00154 // Reverse the order of bytes in a 64 bit quantity for big/little-endian switch. 00155 inline void Reverse64(void* ptr) { 00156 ReverseN(ptr, 8); 00157 } 00158 00159 00160 #endif // TESSERACT_CCUTIL_HELPERS_H_