From 8e268d2e62786e66cf2833a4be734ac725bfe762 Mon Sep 17 00:00:00 2001 From: reyes Date: Thu, 16 Jun 2011 12:28:38 +0000 Subject: [PATCH] *** empty log message *** --- packages/vtk/src/bbtkSimpleUtilities.cxx | 369 +++++++++++++++++++++++ packages/vtk/src/bbtkSimpleUtilities.h | 342 +++++++++++++++++++++ packages/vtk/src/bbtkStaticLecture.cxx | 152 ++++++++++ packages/vtk/src/bbtkStaticLecture.h | 14 + packages/vtk/src/names.cxx | 193 ++++++++++++ packages/vtk/src/names.h | 31 ++ 6 files changed, 1101 insertions(+) create mode 100644 packages/vtk/src/bbtkSimpleUtilities.cxx create mode 100755 packages/vtk/src/bbtkSimpleUtilities.h create mode 100755 packages/vtk/src/bbtkStaticLecture.cxx create mode 100755 packages/vtk/src/bbtkStaticLecture.h create mode 100755 packages/vtk/src/names.cxx create mode 100755 packages/vtk/src/names.h diff --git a/packages/vtk/src/bbtkSimpleUtilities.cxx b/packages/vtk/src/bbtkSimpleUtilities.cxx new file mode 100644 index 0000000..549a56a --- /dev/null +++ b/packages/vtk/src/bbtkSimpleUtilities.cxx @@ -0,0 +1,369 @@ + +#include "bbtkSimpleUtilities.h" +#define LOG_FILE_NAME "log.txt" + +namespace bbtk +{ + + +//template + + + + + +/* +namespace what +{ + std::string kind(int*); + std::string is(int*, bool withkind=false); + std::string kind(double* a); + std::string is(double* a, bool withkind=false); + std::string kind(float* a); + std::string is(float* a, bool withkind=false); + std::string kind(char* a); + std::string is(char* a, bool withkind=false); + std::string kind(long* a); + std::string is(long* a, bool withkind=false); + std::string kind(short* a); + std::string is(short* a, bool withkind=false); + std::string kind(bool* a); + std::string is(bool* a, bool withkind=false); + std::string kind(void* a); + std::string is(void* a, bool withkind=false); + + std::string kind(unsigned int* a); + std::string is(unsigned int* a, bool withkind=false); + std::string kind(unsigned char* a); + std::string is(unsigned char* a, bool withkind=false); + std::string kind(unsigned long* a); + std::string is(unsigned long* a, bool withkind=false); + std::string kind(unsigned short* a); + std::string is(unsigned short* a, bool withkind=false); + std::string kind(__int64* a); + std::string is(__int64* a, bool withkind=false); + std::string kind(unsigned __int64* a); + std::string is(unsigned __int64* a, bool withkind=false); + std::string kind(long double* a); + std::string is(long double* a, bool withkind=false); + + std::string kind(int a); + std::string is(int a, bool withkind=false); + std::string kind(double a); + std::string is(double a, bool withkind=false); + std::string kind(float a); + std::string is(float a, bool withkind=false); + std::string kind(short a); + std::string is(short a, bool withkind=false); + std::string kind(char a); + std::string is(char a, bool withkind=false); + std::string kind(long a); + std::string is(long a, bool withkind=false); + std::string kind(bool a); + std::string is(bool a, bool withkind=false); + std::string kind(unsigned int a); + std::string is(unsigned int a, bool withkind=false); + std::string kind(unsigned char a); + std::string is(unsigned char a, bool withkind=false); + std::string kind(unsigned long a); + std::string is(unsigned long a, bool withkind=false); + std::string kind(unsigned short a); + std::string is(unsigned short a, bool withkind=false); + std::string kind(__int64 a); + std::string is(__int64 a, bool withkind=false); + std::string kind(unsigned __int64 a); + std::string is(unsigned __int64 a, bool withkind=false); + std::string kind(long double a); + std::string is(long double a, bool withkind=false); + + std::string kind(std::vector a); + std::string is(std::vector a, bool withkind=false); + std::string kind(std::vector a); + std::string is(std::vector a, bool withkind=false); + std::string kind(std::vector a); + std::string is(std::vector a, bool withkind=false); + std::string kind(std::vector a); + std::string is(std::vector a, bool withkind=false); + std::string kind(std::vector a); + std::string is(std::vector a, bool withkind=false); + std::string kind(std::vector a); + std::string is(std::vector a, bool withkind=false); + std::string kind(std::vector a); + std::string is(std::vector a, bool withkind=false); + std::string kind(std::vector<__int64> a); + std::string is(std::vector<__int64> a, bool withkind=false); + std::string kind(std::vector a); + std::string is(std::vector a, bool withkind=false); + std::string kind(std::vector a); + std::string is(std::vector a, bool withkind=false); + std::string kind(std::vector a); + std::string is(std::vector a, bool withkind=false); + std::string kind(std::vector a); + std::string is(std::vector a, bool withkind=false); + std::string kind(std::vector a); + std::string is(std::vector a, bool withkind=false); + + std::string is(double* a,int len=1, bool withkind=false); + std::string is(int* a,int len=1, bool withkind=false); + std::string is(float* a,int len=1, bool withkind=false); + std::string is(char* a,int len=1, bool withkind=false); + +} +*/ + + + + bool persistence::writeFile(std::string stm, std::string content) + { + std::ofstream myfile (stm.c_str()); + if (myfile.is_open()) + { + myfile << content; + myfile.close(); + return true; + } + else + { + return false; + } + } + + std::string persistence::readFile(std::string path) + { + std::string line; + std::stringstream stm; + std::ifstream myfile (path.c_str()); + if (myfile.is_open()) + { + while (! myfile.eof() ) + { + getline (myfile,line); + stm << line << std::endl; + } + myfile.close(); + } + else + { + + } + return stm.str(); + } + + + + + std::string logging::fecha() + { + time_t seconds; + seconds = time (NULL); + + //char timeStr [9]; + std::stringstream out; + out << seconds; + std::string la_fecha = out.str(); + //_strtime( timeStr ); + //std::string la_fecha(timeStr); + return "["+la_fecha+"] "; + } + + void logging::out(std::string texto) + { + std::ofstream outFile; + outFile.open(LOG_FILE_NAME, std::ios::app); + if (outFile) + { + outFile << fecha() << texto << std::endl; + } + } + + void logging::erase() + { + std::ofstream outFile; + outFile.open(LOG_FILE_NAME, std::ios::out); + if (outFile) + { + outFile << fecha() << "INICIO" << std::endl; + } + } + + + std::vector translate::StringSplit(std::string str, std::string delim) + { + std::vector results; + int cutAt; + while( (cutAt = (int)str.find_first_of(delim)) != str.npos ) + { + if(cutAt > 0) + { + results.push_back(str.substr(0,cutAt)); + } + str = str.substr(cutAt+1); + } + if(str.length() > 0) + { + results.push_back(str); + } + return results; + } + + std::vector translate::stringTovector(std::string texto, std::string start, std::string end) + { + std::vector el_vector; + std::vector partes; + + + int inicial = (int)texto.find( start, 0 ); + int final = (int)texto.find( end, 0 ); + + if (inicial == std::string::npos || final == std::string::npos) + return el_vector; + if (final<=inicial) + return el_vector; + + std::string contenido = texto.substr(inicial+1, final-inicial-1); + + partes = StringSplit(contenido, ","); + if (partes.size() != -1){ + for (int i=0; i<(int)partes.size(); i++) + { + if (partes.at(i).size() > 0) + { + double uno = atof(partes.at(i).data()); + el_vector.push_back(uno); + } + } + } + return el_vector; + } + + std::vector translate::stringTovectorDelimited(std::string texto, std::string delimitador) + { + std::vector el_vector; + std::vector partes; + + std::string contenido = texto; + + partes = StringSplit(contenido, delimitador); + if (partes.size() != -1){ + for (int i=0; i<(int)partes.size(); i++) + { + double uno = atof(partes.at(i).data()); + el_vector.push_back(uno); + } + } + return el_vector; + } + + double* translate::stringToArray(std::string texto) + { + std::vector el_vector = stringTovector(texto); + double* array = new double[el_vector.size()]; + for (int i=0; i<(int)el_vector.size(); i++) + { + array[i]=el_vector[i]; + } + return array; + } + + std::string translate::getInnerInfo(std::string texto) + { + int first_par = (int)texto.find("[", 0); + int last_par = (int)texto.rfind("]", texto.size()); + + return texto.substr(first_par+1,last_par-first_par-1); + } + + std::vector translate::stringToVectorArray(std::string texto) + { + std::vector el_vector; + std::string innerInfo = getInnerInfo(texto); + + int first_par = 0; + int last_par = 0; + int lastComma = 0; + + while (lastComma != std::string::npos) + { + first_par = (int)innerInfo.find("[", lastComma); + last_par = (int)innerInfo.find("]", lastComma); + lastComma = (int)innerInfo.find(",", last_par); + if (first_par == std::string::npos || last_par == std::string::npos) + break; + std::string subArreglo = innerInfo.substr(first_par,last_par-first_par+1); + double* subArray = stringToArray(subArreglo); + el_vector.push_back(subArray); + } + return el_vector; + } + + std::string translate::vectorToStringDelimited(std::vector a, std::string delim) + { + std::stringstream out; + + unsigned int i; + for (i = 0; i < a.size(); i++) + { + out << a.at(i); + if (i != a.size()-1) + out << delim; + } + return out.str(); + } + + + +//Recorre el vector de manera ciclica +double vectores::vectorInfinite(std::vector in, int index) +{ + //std::cout << "index = " << index; + int value; + int tamanio = in.size(); + bool inverso = false; + if (tamanio == 0) + return -1; + + if (index < 0) + { + inverso = true; + index = abs(index); + value = tamanio - index%tamanio; + if (value == tamanio) + value = 0; + }else{ + value = index%tamanio; + } + //std::cout << ", value=" << value << std::endl; + //return 0; + return in.at(value); +} + + + + /** + Ordenamiento busbuja, array[0] es el maximo + http://mathbits.com/mathbits/compsci/Arrays/Bubble.htm + **/ + void sorts::bubble(std::vector &array) + { + double i, j, flag = 1; // set flag to 1 to begin initial pass + double temp; // holding variable + double arrayLength = array.size(); + for(i = 1; (i <= arrayLength) && flag; i++) + { + flag = 0; + for (j=0; j < (arrayLength -1); j++) + { + if (array[(int)(j+1)] > array[(int)j]) // ascending order simply changes to < + { + temp = array[(int)j]; // swap elements + array[(int)j] = array[(int)(j+1)]; + array[(int)(j+1)] = temp; + flag = 1; // indicates that a swap occurred. + } + } + } + } + +}; + + diff --git a/packages/vtk/src/bbtkSimpleUtilities.h b/packages/vtk/src/bbtkSimpleUtilities.h new file mode 100755 index 0000000..91d2d97 --- /dev/null +++ b/packages/vtk/src/bbtkSimpleUtilities.h @@ -0,0 +1,342 @@ +#ifndef _BBTKSIMPLEUTILITIES_H_ +#define _BBTKSIMPLEUTILITIES_H_ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +namespace bbtk +{ + + + +template +class Memcache +{ +public: + vtkImageData* db; + + Memcache() + { + db = NULL; + } + + ~Memcache() + { + if (db!=NULL) + db->Delete(); + } + + void init(int x, int y, int z) + { + //Se pregunta al OS el tamanio de la palabra de un apuntador + int palabra = sizeof(T); + db = vtkImageData::New(); + db->SetScalarType(Memcache::darTipo(palabra)); + db->SetDimensions(x,y,z); + db->SetOrigin(0, 0, 0); + db->AllocateScalars(); + db->Update(); + } + void* get(int x, int y, int z) + { + T* apap = (T*)db->GetScalarPointer(x,y,z); + void* ap = (void*)*apap; + return ap; + } + + void* pop(int x, int y, int z) + { + T* apap = (T*)db->GetScalarPointer(x,y,z); + void* ap = (void*)*apap; + *apap = NULL; + return ap; + } + + void put(int x, int y, int z, void* apt) + { + T* punto = (T*)db->GetScalarPointer(x,y,z); + *punto = (T)apt; + } + void clear() + { + int ext[6]; + db->GetExtent(ext); + T* ap1; + for (int i=ext[0]; i<=ext[1]; i++) + { + for (int j=ext[2]; j<=ext[3]; j++) + { + for (int k=ext[4]; k<=ext[5]; k++) + { + ap1 = (T*)db->GetScalarPointer(i,j,k); + *ap1 = NULL; + } + } + } + } + static int darTipo(int tamanio) + { + if (tamanio == sizeof(char)) + return VTK_CHAR; + if (tamanio == sizeof(unsigned char)) + return VTK_UNSIGNED_CHAR; + if (tamanio == sizeof(short)) + return VTK_SHORT; + if (tamanio == sizeof(unsigned short)) + return VTK_UNSIGNED_SHORT; + if (tamanio == sizeof(int)) + return VTK_INT; + if (tamanio == sizeof(unsigned int)) + return VTK_UNSIGNED_INT; + if (tamanio == sizeof(long)) + return VTK_LONG; + if (tamanio == sizeof(unsigned long)) + return VTK_UNSIGNED_LONG; + if (tamanio == sizeof(float)) + return VTK_FLOAT; + if (tamanio == sizeof(double)) + return VTK_DOUBLE; + return 0; + } + +}; + + +class tiempo +{ + public: + static time_t first, second; + static double bytes; +static void tic(vtkImageData* img) + { + tiempo::bytes = VTK_SIZE(img); + tiempo::first = time (NULL); + } + static void tic(int bytes_=0) + { + tiempo::bytes = bytes_; + tiempo::first = time (NULL); + } + + static void toc() + { + tiempo::second = time (NULL); + double diferencia = difftime (tiempo::second,tiempo::first); + printf ("Total time for %f Bytes is %f (%f Bytes/s)\n", tiempo::bytes, diferencia, tiempo::bytes/diferencia); + } + + static int VTK_SIZE(vtkImageData* img) + { + int dims[3]; + img->GetDimensions(dims); + int tamanio = VTK_SIZE_T(img->GetScalarType()); + std::cout << "[" << dims[0] << "x" << dims[1] << "x" << dims[2] << "x" << tamanio << "]" << std::endl; + return dims[0]*dims[1]*dims[2]*tamanio; + } + static int VTK_SIZE_T(int tipo) + { + switch(tipo) + { + case VTK_CHAR: + return sizeof(char); + break; + case VTK_UNSIGNED_CHAR: + return sizeof(unsigned char); + break; + case VTK_SHORT: + return sizeof(short); + break; + case VTK_UNSIGNED_SHORT: + return sizeof(unsigned short); + break; + case VTK_INT: + return sizeof(int); + break; + case VTK_UNSIGNED_INT: + return sizeof(unsigned int); + break; + case VTK_LONG: + return sizeof(long); + break; + case VTK_UNSIGNED_LONG: + return sizeof(unsigned long); + break; + case VTK_FLOAT: + return sizeof(float); + break; + case VTK_DOUBLE: + return sizeof(double); + break; + default: + return 0; + break; + } + } +}; + +/* +namespace what +{ + std::string kind(int*); + std::string is(int*, bool withkind=false); + std::string kind(double* a); + std::string is(double* a, bool withkind=false); + std::string kind(float* a); + std::string is(float* a, bool withkind=false); + std::string kind(char* a); + std::string is(char* a, bool withkind=false); + std::string kind(long* a); + std::string is(long* a, bool withkind=false); + std::string kind(short* a); + std::string is(short* a, bool withkind=false); + std::string kind(bool* a); + std::string is(bool* a, bool withkind=false); + std::string kind(void* a); + std::string is(void* a, bool withkind=false); + + std::string kind(unsigned int* a); + std::string is(unsigned int* a, bool withkind=false); + std::string kind(unsigned char* a); + std::string is(unsigned char* a, bool withkind=false); + std::string kind(unsigned long* a); + std::string is(unsigned long* a, bool withkind=false); + std::string kind(unsigned short* a); + std::string is(unsigned short* a, bool withkind=false); + std::string kind(__int64* a); + std::string is(__int64* a, bool withkind=false); + std::string kind(unsigned __int64* a); + std::string is(unsigned __int64* a, bool withkind=false); + std::string kind(long double* a); + std::string is(long double* a, bool withkind=false); + + std::string kind(int a); + std::string is(int a, bool withkind=false); + std::string kind(double a); + std::string is(double a, bool withkind=false); + std::string kind(float a); + std::string is(float a, bool withkind=false); + std::string kind(short a); + std::string is(short a, bool withkind=false); + std::string kind(char a); + std::string is(char a, bool withkind=false); + std::string kind(long a); + std::string is(long a, bool withkind=false); + std::string kind(bool a); + std::string is(bool a, bool withkind=false); + std::string kind(unsigned int a); + std::string is(unsigned int a, bool withkind=false); + std::string kind(unsigned char a); + std::string is(unsigned char a, bool withkind=false); + std::string kind(unsigned long a); + std::string is(unsigned long a, bool withkind=false); + std::string kind(unsigned short a); + std::string is(unsigned short a, bool withkind=false); + std::string kind(__int64 a); + std::string is(__int64 a, bool withkind=false); + std::string kind(unsigned __int64 a); + std::string is(unsigned __int64 a, bool withkind=false); + std::string kind(long double a); + std::string is(long double a, bool withkind=false); + + std::string kind(std::vector a); + std::string is(std::vector a, bool withkind=false); + std::string kind(std::vector a); + std::string is(std::vector a, bool withkind=false); + std::string kind(std::vector a); + std::string is(std::vector a, bool withkind=false); + std::string kind(std::vector a); + std::string is(std::vector a, bool withkind=false); + std::string kind(std::vector a); + std::string is(std::vector a, bool withkind=false); + std::string kind(std::vector a); + std::string is(std::vector a, bool withkind=false); + std::string kind(std::vector a); + std::string is(std::vector a, bool withkind=false); + std::string kind(std::vector<__int64> a); + std::string is(std::vector<__int64> a, bool withkind=false); + std::string kind(std::vector a); + std::string is(std::vector a, bool withkind=false); + std::string kind(std::vector a); + std::string is(std::vector a, bool withkind=false); + std::string kind(std::vector a); + std::string is(std::vector a, bool withkind=false); + std::string kind(std::vector a); + std::string is(std::vector a, bool withkind=false); + std::string kind(std::vector a); + std::string is(std::vector a, bool withkind=false); + + std::string is(double* a,int len=1, bool withkind=false); + std::string is(int* a,int len=1, bool withkind=false); + std::string is(float* a,int len=1, bool withkind=false); + std::string is(char* a,int len=1, bool withkind=false); +} + +*/ + +class persistence +{ + public: + bool writeFile(std::string stm, std::string content); + std::string readFile(std::string stm); +}; + +class logging +{ + public: + std::string fecha(); + void out(std::string texto); + void erase(); +}; + +class translate +{ + public: + /** + el texto debe ser de la forma [12,45.6] y retorna un vector con la informacion esperada + **/ + std::vector stringTovector(std::string, std::string start="[", std::string end="]"); + /** + Ayuda a parsear una linea de texto que contiene numeros + */ + std::vector stringTovectorDelimited(std::string, std::string); + + std::string vectorToStringDelimited(std::vector a, std::string delim); + std::vector stringToVectorArray(std::string); + /** + StringSplit toma str y lo parte por el delimitador delim y retorna el vector de partes + **/ + std::vector StringSplit(std::string, std::string); + /** + Lo mismo que stringTovector, pero retornando un arreglo en vez de un vector + **/ + double* stringToArray(std::string); + std::string getInnerInfo(std::string); +// std::vector stringToVectorArray(std::string); +}; + +class vectores +{ + public: + //Recorre el vector de manera ciclica + double vectorInfinite(std::vector in, int index); +}; + +class sorts +{ + public: + void bubble(std::vector &array); +}; + +} + +#endif /* _DLL_H_ */ diff --git a/packages/vtk/src/bbtkStaticLecture.cxx b/packages/vtk/src/bbtkStaticLecture.cxx new file mode 100755 index 0000000..c1a9adc --- /dev/null +++ b/packages/vtk/src/bbtkStaticLecture.cxx @@ -0,0 +1,152 @@ +#include "bbtkStaticLecture.h" + + + void bbtkStaticLecture::setPixelValue(int i, int j, int k, vtkImageData* img, double value) + { + //double rta; + int scalar_type = img->GetScalarType(); + int* ext = img->GetExtent(); + if (i < ext[0]) + return; + if (i > ext[1]) + return; + + if (j < ext[2]) + return; + if (j > ext[3]) + return; + + if (k < ext[4]) + return; + if (k > ext[5]) + return; + + switch (scalar_type) + { + case VTK_CHAR: + char * ap2; + ap2 = (char *) img->GetScalarPointer(i,j,k); + *ap2 = (char) value; + break; + case VTK_UNSIGNED_CHAR: + unsigned char * ap3; + ap3 = (unsigned char *) img->GetScalarPointer(i,j,k); + *ap3 = (unsigned char) value; + break; + case VTK_SHORT: + short * ap4; + ap4 = (short *) img->GetScalarPointer(i,j,k); + *ap4 = (short) value; + break; + case VTK_UNSIGNED_SHORT: + unsigned short * ap5; + ap5 = (unsigned short *) img->GetScalarPointer(i,j,k); + *ap5 = (unsigned short) value; + break; + case VTK_INT: + int * ap6; + ap6 = (int *) img->GetScalarPointer(i,j,k); + *ap6 = (int) value; + break; + case VTK_UNSIGNED_INT: + unsigned int * ap7; + ap7 = (unsigned int *) img->GetScalarPointer(i,j,k); + *ap7 = (unsigned int) value; + break; + case VTK_LONG: + long * ap8; + ap8 = (long *) img->GetScalarPointer(i,j,k); + *ap8 = (long) value; + break; + case VTK_UNSIGNED_LONG: + unsigned long * ap9; + ap9 = (unsigned long *) img->GetScalarPointer(i,j,k); + *ap9 = (unsigned long) value; + break; + case VTK_FLOAT: + float * ap10; + ap10 = (float *) img->GetScalarPointer(i,j,k); + *ap10 = (float) value; + break; + case VTK_DOUBLE: + double * ap11; + ap11 = (double *) img->GetScalarPointer(i,j,k); + *ap11 = (double) value; + break; + } + } + double bbtkStaticLecture::getPixelValue(int i, int j, int k, vtkImageData* img) + { + double rta; + int scalar_type = img->GetScalarType(); + int* ext = img->GetExtent(); + if (i < ext[0]) + i=ext[0]; + if (i > ext[1]) + i=ext[1]; + + if (j < ext[2]) + j=ext[2]; + if (j > ext[3]) + j=ext[3]; + + if (k < ext[4]) + k=ext[4]; + if (k > ext[5]) + k=ext[5]; + + switch (scalar_type) + { + case VTK_CHAR: + char * ap2; + ap2 = (char *) img->GetScalarPointer(i,j,k); + rta = (double) *ap2; + break; + case VTK_UNSIGNED_CHAR: + unsigned char * ap3; + ap3 = (unsigned char *) img->GetScalarPointer(i,j,k); + rta = (double) *ap3; + break; + case VTK_SHORT: + short * ap4; + ap4 = (short *) img->GetScalarPointer(i,j,k); + rta = (double) *ap4; + break; + case VTK_UNSIGNED_SHORT: + unsigned short * ap5; + ap5 = (unsigned short *) img->GetScalarPointer(i,j,k); + rta = (double) *ap5; + break; + case VTK_INT: + int * ap6; + ap6 = (int *) img->GetScalarPointer(i,j,k); + rta = (double) *ap6; + break; + case VTK_UNSIGNED_INT: + unsigned int * ap7; + ap7 = (unsigned int *) img->GetScalarPointer(i,j,k); + rta = (double) *ap7; + break; + case VTK_LONG: + long * ap8; + ap8 = (long *) img->GetScalarPointer(i,j,k); + rta = (double) *ap8; + break; + case VTK_UNSIGNED_LONG: + unsigned long * ap9; + ap9 = (unsigned long *) img->GetScalarPointer(i,j,k); + rta = (double) *ap9; + break; + case VTK_FLOAT: + float * ap10; + ap10 = (float *) img->GetScalarPointer(i,j,k); + rta = (double) *ap10; + break; + case VTK_DOUBLE: + double * ap11; + ap11 = (double *) img->GetScalarPointer(i,j,k); + rta = (double) *ap11; + break; + } + return rta; + } diff --git a/packages/vtk/src/bbtkStaticLecture.h b/packages/vtk/src/bbtkStaticLecture.h new file mode 100755 index 0000000..1616921 --- /dev/null +++ b/packages/vtk/src/bbtkStaticLecture.h @@ -0,0 +1,14 @@ +#ifndef __bbtkStaticLecture__h__ +#define __bbtkStaticLecture__h__ + +#include +#include + +class bbtkStaticLecture +{ +public: + void setPixelValue(int i, int j, int k, vtkImageData* img, double value); + double getPixelValue(int i, int j, int k, vtkImageData* img); +}; + +#endif diff --git a/packages/vtk/src/names.cxx b/packages/vtk/src/names.cxx new file mode 100755 index 0000000..dfdb011 --- /dev/null +++ b/packages/vtk/src/names.cxx @@ -0,0 +1,193 @@ +#include "names.h" + +bool checknum(std::string s) +{ + std::istringstream iss(s); + std::ostringstream oss; + int x; + iss >> x; + oss << x; + + if( s == oss.str()) + return true; + + return false; +} + + + +std::string StringClear(std::string in, std::vector no) +{ + size_t found; + +for (int i=0; i StringSplit(std::string str, std::string delim) +{ + std::vector results; + int cutAt; + while( (cutAt = (int)str.find_first_of(delim)) != str.npos ) + { + if(cutAt > 0) + { + results.push_back(str.substr(0,cutAt)); + } + str = str.substr(cutAt+1); + } + if(str.length() > 0) + { + results.push_back(str); + } + return results; +} + +std::string generateFileName(std::string input, int number, std::string prefix) +{ + // + int ceros = 6; + int position = input.find( "\\" ); // find first space + while ( position != std::string::npos ) + { + input.replace( position, 1, "/" ); + position = input.find( "\\", position + 1 ); + } + + bool comienza_con_slash = false; + + if (input.at(0) == '/') + comienza_con_slash = true; + // + std::vector< std::string > partes = StringSplit(input, "/"); + + std::stringstream number_str; + number_str << number; + std::string number_str_texto = number_str.str(); + + + int tamanio = number_str_texto.size(); + int diferencia = ceros-tamanio; + for (int i=0; i partes_punto; + partes_punto = StringSplit(partes[i], "."); + /* + La extension es: partes_punto[partes_punto.size()-1] + */ + std::string oldname = ""; + for (unsigned int h=0; h 1) + rta+="/"+prefix+"_"+oldname+"_"+number_str_texto+"."+partes_punto[partes_punto.size()-1]; + else + rta+="/"+prefix+"_"+oldname+"_"+number_str_texto; + } + else + { + rta+="/"+partes[i]; + } + } + if (comienza_con_slash) + rta = "/"+rta; + return rta; +} + +bool existFile(std::string myFileName) +{ + std::ifstream inp; +inp.open(myFileName.c_str(), std::ifstream::in); +inp.close(); +if (!inp.fail()) +{ + return true; +}else{ + return false; +} +} + +std::string guessName(std::string nombre) +{ + int iterador = 0; + int max_iter = 10000; + + while(iterador < max_iter) + { + std::string nuevo = generateFileName(nombre, iterador, "Data"); + + if (existFile(nuevo)) + { + iterador++; + } + else + { + std::cout << nuevo << std::endl; + return nuevo; + } + } + std::cout << nombre << std::endl; + return nombre; +} + +std::string guessExistent(std::string nombre, int* actual, bool* hay) +{ + std::string nada = ""; + if (actual == NULL || hay == NULL) + return nada; + int iterador = *actual; + int max_iter = 1000; + + while(iterador < max_iter) + { + std::string nuevo = generateFileName(nombre, iterador, "Data"); + + if (existFile(nuevo)) + { + *hay = true; + *actual = iterador; + return nuevo; + } + else + { + iterador++; + } + } + *hay = false; + return nada; +} diff --git a/packages/vtk/src/names.h b/packages/vtk/src/names.h new file mode 100755 index 0000000..c34a372 --- /dev/null +++ b/packages/vtk/src/names.h @@ -0,0 +1,31 @@ +#include +#include +#include +#include +#include +#include +#include +#include + +#include + + + +bool checknum(std::string s); + +std::string StringReplace(std::string in, std::string, std::string); + +/* +Elimina todas las ocurrencias de las cadenas de texto +*/ +std::string StringClear(std::string in, std::vector); + +std::vector < std::string > StringSplit(std::string str, std::string delim); + +std::string generateFileName(std::string input, int number, std::string prefix); + +bool existFile(std::string myFileName); + +std::string guessName(std::string nombre); + +std::string guessExistent(std::string nombre, int* actual, bool* hay); -- 2.45.1