Tesseract 3.01
|
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 if (last_index >= 0 && str[last_index] == '\n') { 00035 str[last_index] = '\0'; 00036 } 00037 } 00038 00039 // Advance the current pointer of the file if it points to a newline character. 00040 inline void SkipNewline(FILE *file) { 00041 if (fgetc(file) != '\n') fseek(file, -1, SEEK_CUR); 00042 } 00043 00044 // qsort function to sort 2 floats. 00045 inline int sort_floats(const void *arg1, const void *arg2) { 00046 float diff = *((float *) arg1) - *((float *) arg2); 00047 if (diff > 0) { 00048 return 1; 00049 } else if (diff < 0) { 00050 return -1; 00051 } else { 00052 return 0; 00053 } 00054 } 00055 00056 // return the smallest multiple of block_size greater than or equal to n. 00057 inline int RoundUp(int n, int block_size) { 00058 return block_size * ((n + block_size - 1) / block_size); 00059 } 00060 00061 // Clip a numeric value to the interval [lower_bound, upper_bound]. 00062 template<typename T> 00063 inline T ClipToRange(const T& x, const T& lower_bound, const T& upper_bound) { 00064 if (x < lower_bound) 00065 return lower_bound; 00066 if (x > upper_bound) 00067 return upper_bound; 00068 return x; 00069 } 00070 00071 // Extend the range [lower_bound, upper_bound] to include x. 00072 template<typename T1, typename T2> 00073 inline void UpdateRange(const T1& x, T2* lower_bound, T2* upper_bound) { 00074 if (x < *lower_bound) 00075 *lower_bound = x; 00076 if (x > *upper_bound) 00077 *upper_bound = x; 00078 } 00079 00080 // Decrease lower_bound to be <= x_lo AND increase upper_bound to be >= x_hi. 00081 template<typename T1, typename T2> 00082 inline void UpdateRange(const T1& x_lo, const T1& x_hi, 00083 T2* lower_bound, T2* upper_bound) { 00084 if (x_lo < *lower_bound) 00085 *lower_bound = x_lo; 00086 if (x_hi > *upper_bound) 00087 *upper_bound = x_hi; 00088 } 00089 00090 // Proper modulo arithmetic operator. Returns a mod b that works for -ve a. 00091 // For any integer a and positive b, returns r : 0<=r<b and a=n*b + r for 00092 // some integer n. 00093 inline int Modulo(int a, int b) { 00094 return (a % b + b) % b; 00095 } 00096 00097 // Integer division operator with rounding that works for negative input. 00098 // Returns a divided by b, rounded to the nearest integer, without double 00099 // counting at 0. With simple rounding 1/3 = 0, 0/3 = 0 -1/3 = 0, -2/3 = 0, 00100 // -3/3 = 0 and -4/3 = -1. 00101 // I want 1/3 = 0, 0/3 = 0, -1/3 = 0, -2/3 = -1, -3/3 = -1 and -4/3 = -1. 00102 // Results with b negative are not defined. 00103 inline int DivRounded(int a, int b) { 00104 return a >= 0 ? (a + b / 2) / b : (a - b / 2) / b; 00105 } 00106 00107 // Return a double cast to int with rounding. 00108 inline int IntCastRounded(double x) { 00109 return x >= 0.0 ? static_cast<int>(x + 0.5) : -static_cast<int>(-x + 0.5); 00110 } 00111 00112 // Reverse the order of bytes in a n byte quantity for big/little-endian switch. 00113 inline void ReverseN(void* ptr, int num_bytes) { 00114 char *cptr = reinterpret_cast<char *>(ptr); 00115 int halfsize = num_bytes / 2; 00116 for (int i = 0; i < halfsize; ++i) { 00117 char tmp = cptr[i]; 00118 cptr[i] = cptr[num_bytes - 1 - i]; 00119 cptr[num_bytes - 1 - i] = tmp; 00120 } 00121 } 00122 00123 // Reverse the order of bytes in a 16 bit quantity for big/little-endian switch. 00124 inline void Reverse16(void *ptr) { 00125 ReverseN(ptr, 2); 00126 } 00127 00128 // Reverse the order of bytes in a 32 bit quantity for big/little-endian switch. 00129 inline void Reverse32(void *ptr) { 00130 ReverseN(ptr, 4); 00131 } 00132 00133 // Reverse the order of bytes in a 64 bit quantity for big/little-endian switch. 00134 inline void Reverse64(void* ptr) { 00135 ReverseN(ptr, 8); 00136 } 00137 00138 00139 #endif // TESSERACT_CCUTIL_HELPERS_H_