Tesseract 3.01
/data/source/tesseract-ocr/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   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_
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines