tesseract  3.03
/usr/local/google/home/jbreiden/tesseract-ocr-read-only/ccutil/helpers.h
Go to the documentation of this file.
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_
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines